我在前面的一片博客中，介绍了jPBC 2.0.0在PC平台上面的配置和测试。既然jPBC是Java平台上面实现的，那么jPBC能不能在Android这个以Java为主要语言的平台上运行呢？这样一来，各种在jPBC上撰写的有关双线性对的函数就都能够在移动终端上面用了。我个人的想法就是把最新的密码学算法应用到工程里面，而这确实是我想法的一个很好的跨越。因此，我在第一时间公开整个配置的过程以及我测试的方法，以供广大国内密码学研究者们进行尝试。整个配置过程实际上是非常简单的，这也要感谢jPBC库的编写者们的辛勤工作。在整个配置过程中，我几乎可以确定，jPBC的开发者们在2.0.0版本中完全抛离了GMP库和PBC库，而是将整个PBC在Java上进行了完整的实现。而唯一没有实现的部分，也就是椭圆曲线常数产生部分，作者也使用了相同的配置格式，以使得PBC中使用的椭圆曲线常数可以在jPBC中直接使用。

用到的库工具

Android Development Tools

首先用到的当然是Android的开发工具啦。我使用的是Windows下面的ADT工具。这个工具已经被Google统一打包。也就是说，现在大家开发Android的时候，再也不用下载Eclipse，下载Android SDK，下载Android ADT，进行各种复杂的配置后才能使用了。Google将整个开发工具集成在了一起。这个集成工具的下载地址为：http://developer.android.com/sdk/index.html。里面包含了包括Eclipse，Android SDK Manager，Android ADT在内的全套工具。

然而，如果是Linux平台下面的开发者，虽然Google也提供了Linux下面的Android打包开发工具，但是我建议大家不要使用这一打包工具，而是手动进行一步一步地配置。实际上，如果大家在网上进行检索，会发现网上已经有很多很多的人在抱怨Linux下面Android打包开发工具的各种问题。所以，本着不给自己找麻烦的初衷，大家还是老老实实手动配置吧~

jPBC 2.0.0

jPBC 2.0.0也是必不可少的。其官方网站为：http://gas.dia.unisa.it/projects/jpbc/index.html。需要指出的是，虽然网站中专门有一项是Android，但是里面没有给出任何配置或者使用的方法，有的只是下面的一段话：

JPBC runs out of box on Android (2.1+ version).

所以如果大家想使用Android jPBC，确实需要自己摸索一下怎么配置，这也是我写这篇博客的根本目的。同时，这一段话也可以让我们确信jPBC是可以在Android上面运行的，毕竟连APK都已经有了嘛~

jpbc-android运行

我们首先尝试将jPBC中提供的APK文件恢复成工程文件。我们将分三步介绍恢复的方法：整理并准备需要的文件、Android-jpbc工程的建立和配置、运行Benchmark并显示结果。

需要的文件

下载好jPBC 2.0.0的源文件后，解压，观察一下解压的结果。我们可以发现，在解压文件中有个文件夹名字为jpbc-android，这里面存放了一些源文件，同时也存放了打包好的APK文件。原文件中包括了APK文件中使用的resources，有icon、layout、甚至可以找到AndroidManifest.xml。同时，在src文件中可以找到APK工程中需要的三个java源代码：AndroidBenchmark.java、Benchmark.java以及JPBCBenchmarkActivity.java。在asserts文件夹下，存放了4个用于测试的椭圆曲线常数Properties：a.properties、d159.properties、d201.properties，以及d224.properties。这四个文件也是回复APK工程的必要文件。以上这些就是jpbc-android里面所需要的全部文件了。

对于jPBC 2.0.0中的jar文件夹，里面的两个必要jar文件也是我们需要的library：jpbc-api-2.0.0.jar和jpbc-plaf-2.0.0.jar。

好啦，所有必要的文件都准备完毕，开始进行工程的建立。

工程的建立与配置

1. 在Eclipse的Android开发环境中建立一个新的空工程。在我的测试中，我的工程名称为Android-jPBC。

2. 将给出的AndroidManifest.xml引入到工程中。

这一步比较简单，大家可以直接打开工程中的AndroidManifest.xml文件，然后用jpbc-android文件夹下面的同名文件对此文件进行覆盖，当然也可以使用其他任意的方法。修改结果如图。在此跟大家道个歉，我截图的时候正好QQ上有一个好友上线提醒了… 为了保护朋友的隐私我把QQ上面的信息抹掉了，这也是这个图里面我唯一手动改动的部分。

AndroidManifest.xml修改后，我们会发现系统有个报错，说找不到icon文件。这个是Android新版本的问题。在旧的Android版本中，程序的默认图标就为icon。而在新版本的开发环境中，图标名称已经变为了ic_launcher了。因此，我们只需要在源代码中修改这一部分，把名称改为ic_launcher。或者把图标的源文件名称修改为icon，这两种方法都可以。我使用的是第一种方法，修改结果如图。大家可以看到，系统已经不报错了。

3. 引入其他必要的文件

我们还需要引入的文件有：三个源代码文件，layout文件，assert中的四个椭圆曲线常数文件， 以及必要的jar文件。

我们首先将三个源代码文件引入到工程中。引入结果如图。我们可以发现，引入后系统报了很多错误，这是因为其他一些必要的文件还没有引入成功。

随后，我们分别更新layout文件、asserts文件以及jar文件。layout文件的引入和AndroidManifest.xml文件引入方法相同，在此就不再重复说明了。直接看图：

asserts文件引入方法很简单，直接将四个Properties文件复制到asserts目录下，然后在Eclipse工程中刷新即可。需要注意的是jar文件。引入的方法是，在libs文件夹下点击右键->import，然后选择两个文件即可。注意，大家不需要再按照PC上面jPBC的配置方法，在工程的Properties下面进行多余的设置了。因为Android默认会将libs文件夹下面的全部文件作为自己jar库的一部分。配置的结果如图。

至此，所有的配置就全部搞定了。大家注意，与以前的jPBC 1.2.1不同的是，jPBC 2.0.0的配置没有涉及到任何有关Native Library的内容。也就是说，jPBC的编写者们已经把PBC的所有核心功能都写在了Java中，没有涉及到任何原始PBC的调用，这极大地增强了jPBC的可移植性。同时，这也使得jPBC在Windows下面进行开发称为可能。

Benchmark运行

所有内容配置完毕后，就可以运行啦。我们将手机连接电脑后，run这个工程即可。随后，手机端会弹出如下图所示的界面。

中间的iteration是测试的总次数。为了较快地给大家展示测试的效果，我这里面只让他运行一轮。点击Benchmark后，程序将进行测试。等待一段时间后，程序会体制Benchmark已经测试完毕，测试结果已经输出。

那么，测试结果输出到哪里了呢？jpbc-android默认将输出结果放置在Android内置SD卡中的根目录下。实际上，测试完毕后我们可以在SD卡根目录下面找打一个叫做benchmark.out的文件，这个文件存储的就是测试结果。jpbc-android的测试结果输出格式是html格式，因此大家可以用IE浏览器等各种浏览器直接打开这个文件，查询测试的结果，如图所示。

BBG-HIBE在Android的运行

Benchmark的测试结果只能显示时间等信息，那么jpbc-android到底能不能成功运行呢？我现在将以前博客中撰写的BBGHIBE方案也移植到Android中，看看能否得到正确的结果。

BBGHIBE中涉及到的源代码几乎不需要做任何修改，只有两个地方需要特别注意：

1. 在PC中，输出的方法是System.out.println，而在Android中，推荐的输出方法是Log.i。因此，所有的System.out.println都需要改成Log.i的形式，举例：

Log.i(tag, "Infor - encrypt: the generated random message is " + message);  

2. 特别要注意Properties的路径需要修改成Android下面的路径：assets/a.properties。因此，在TestBBGHIBE.java中，需要做如下修改：

BBGHIBEMasterKey msk = bbgHIBE.Setup("assets/a.properties", 7);  

其他地方呢，就是为了让Android成功调用TestBBGHIBE函数所作出的修改啦。后面我会放置所有需要修改的源代码。我们尝试运行一下，运行两次测试，两次都能得到正确的结果，并且两次的消息都不相同，这证明jpbc-android确实能够在Android下面正确的运行。

源代码汇总

BBGHIBE.java

package cn.edu.buaa.crypto;


import android.util.Log;
import it.unisa.dia.gas.jpbc.Element;  
import it.unisa.dia.gas.jpbc.Pairing;  
import it.unisa.dia.gas.plaf.jpbc.pairing.PairingFactory;  
  
public class BBGHIBE {  
    public static final boolean isDebug = true;  
    private static final String tag = "BBGHIBE";
    private Pairing pairing;  
    private int MAX_DEPTH;  
    //Public parameters  
    private Element g;  
    private Element h;  
    private Element[] u;  
    private Element E_g_g;  
      
    /** 
     * System setup algorithms, takes the max depth of hierarchy as input, and outputs the master secret key 
     * @param perperties The file name of the elliptic curve parameters 
     * @param D Maximal depth of hierarchy 
     * @return Master Secret Key 
     */  
    public BBGHIBEMasterKey Setup(String perperties, int D){  
        // Generate curve parameters  
        pairing = PairingFactory.getPairing(perperties);  
          
        this.MAX_DEPTH = D;  
          
        //generate alpha  
        Element alpha = pairing.getZr().newRandomElement().getImmutable();  
          
        // Generate public parameters  
        this.g = pairing.getG1().newRandomElement().getImmutable();  
        this.h = pairing.getG1().newRandomElement().getImmutable();  
        this.u = new Element[this.MAX_DEPTH];  
        for (int i=0; i<this.u.length; i++){  
            this.u[i] = pairing.getG1().newRandomElement().getImmutable();  
        }  
        this.E_g_g = pairing.pairing(this.g, this.g).powZn(alpha).getImmutable();  
          
        //generate master secret key  
        BBGHIBEMasterKey masterKey = new BBGHIBEMasterKey();  
        masterKey.alpha = alpha.duplicate().getImmutable();  
        return masterKey;  
    }  
      
    /** 
     * Key Generation algorithm to generate secret key associated with the given identity vector 
     * @param msk master secret key 
     * @param identityVector the given identity vector 
     * @return secret key associated with the given identity vector 
     */  
    public BBGHIBESecretKey KeyGen(BBGHIBEMasterKey msk, String[] identityVector){  
        //Determine the validity of Identity Vector  
        assert(identityVector.length <= this.MAX_DEPTH);  
          
        //generate the secret key  
        Element r = pairing.getZr().newRandomElement().getImmutable();  
        BBGHIBESecretKey secretKey = new BBGHIBESecretKey();  
        secretKey.identityVector = new String[identityVector.length];  
        System.arraycopy(identityVector, 0, secretKey.identityVector, 0, identityVector.length);  
          
        //compute K_1  
        secretKey.K_1 = this.g.powZn(r).getImmutable();  
          
        //compute K_2  
        secretKey.K_2 = this.h.duplicate();  
        for (int i=0; i<identityVector.length; i++){  
            secretKey.K_2 = secretKey.K_2.mul(this.u[i].powZn(Util.hash_id(pairing, identityVector[i])));  
        }  
        secretKey.K_2 = secretKey.K_2.powZn(r);  
        secretKey.K_2 = secretKey.K_2.mul(this.g.powZn(msk.alpha)).getImmutable();  
          
        //compute E  
        secretKey.E = new Element[this.MAX_DEPTH];  
        for (int i=identityVector.length; i<this.MAX_DEPTH; i++){  
            secretKey.E[i] = this.u[i].powZn(r).getImmutable();  
        }  
        return secretKey;  
    }  
      
    /** 
     * Delegation algorithm to delegate a secret key for the user‘s subordinate 
     * @param secretkey the secret key for the supervisor 
     * @param identity the identity for the user‘s subordinate 
     * @return secret key for the user‘s subordinate 
     */  
    public BBGHIBESecretKey Delegate(BBGHIBESecretKey secretkey, String identity){  
        //Determine the validity of Identity Vector  
        assert(secretkey.identityVector.length < this.MAX_DEPTH);  
          
        //delegate the secret key  
        BBGHIBESecretKey delegateKey = new BBGHIBESecretKey();  
        String[] delegateIV = new String[secretkey.identityVector.length + 1];  
        System.arraycopy(secretkey.identityVector, 0, delegateIV, 0, secretkey.identityVector.length);  
        delegateIV[secretkey.identityVector.length] = identity;  
        delegateKey.identityVector = delegateIV;  
        Element r = pairing.getZr().newRandomElement().getImmutable();  
          
        //compute K_1  
        delegateKey.K_1 = secretkey.K_1.duplicate();  
        delegateKey.K_1 = delegateKey.K_1.mul(this.g.powZn(r)).getImmutable();  
                  
        //compute K_2  
        delegateKey.K_2 = this.h.duplicate();  
        for (int i=0; i<delegateIV.length; i++){  
            delegateKey.K_2 = delegateKey.K_2.mul(this.u[i].powZn(Util.hash_id(pairing, delegateIV[i])));  
        }  
        delegateKey.K_2 = delegateKey.K_2.powZn(r);  
        delegateKey.K_2 = delegateKey.K_2.mul(secretkey.K_2);  
        delegateKey.K_2 = delegateKey.K_2.mul(secretkey.E[secretkey.identityVector.length].powZn(Util.hash_id(pairing, identity))).getImmutable();  
          
        //compute b  
        delegateKey.E = new Element[this.MAX_DEPTH];  
        for (int i=secretkey.identityVector.length; i<this.MAX_DEPTH; i++){  
            delegateKey.E[i] = this.u[i].powZn(r).mul(secretkey.E[i]).getImmutable();  
        }  
        return delegateKey;  
    }  
      
    /** 
     * Encrypt algorithm to an identity vector 
     * @param identityVector the target identity vector 
     * @return the ciphertext 
     */  
    public BBGHIBECiphertext Encrypt(String[] identityVector){  
        //Determine the validity of Identity Vector  
        assert(identityVector.length <= this.MAX_DEPTH);  
          
        //Generate a random message  
        Element message = pairing.getGT().newRandomElement();  
        if (isDebug){  
        	Log.i(tag, "Infor - encrypt: the generated random message is " + message);  
        }  
          
        //Encrypt that message  
        Element s = pairing.getZr().newRandomElement().getImmutable();  
        BBGHIBECiphertext ciphertext = new BBGHIBECiphertext();  
        //compute C_0  
        ciphertext.C_0 = this.E_g_g.powZn(s).mul(message).getImmutable();  
          
        //compute C_2  
        ciphertext.C_2 = this.g.powZn(s).getImmutable();  
                  
        //compute c_1  
        ciphertext.C_1 = this.h.duplicate();  
        for (int i=0; i<identityVector.length; i++){  
            ciphertext.C_1 = ciphertext.C_1.mul(this.u[i].powZn(Util.hash_id(pairing, identityVector[i])));  
        }  
        ciphertext.C_1 = ciphertext.C_1.powZn(s).getImmutable();  
        return ciphertext;  
    }  
      
    /** 
     * Decrypt the ciphertext using a secret key 
     * @param identityVector the receive identity vector 
     * @param ciphertext the ciphertext 
     * @param secretKey the secret key for the receiver or for the receiver‘s supervisor 
     * @return the message 
     */  
    public Element decrypt(String[] identityVector, BBGHIBECiphertext ciphertext, BBGHIBESecretKey secretKey){  
        //Determine the validity of Identity Vector, the ciphertext and the secret key  
        //Secret Key Identity Vector depth needs to be smaller than ciphertext Identity Vector depth  
        assert(identityVector.length >= secretKey.identityVector.length);  
          
        //the identity vector for the secret key should match the receiver‘s identity vector  
        for (int i=0; i<secretKey.identityVector.length; i++){  
            assert(secretKey.identityVector[i].equals(identityVector[i]));  
        }  
          
        Element K = secretKey.K_2.duplicate();  
        for (int i=secretKey.identityVector.length; i<identityVector.length; i++){  
            K.mul(secretKey.E[i].powZn(Util.hash_id(pairing, identityVector[i])));  
        }  
        Element message = pairing.pairing(secretKey.K_1, ciphertext.C_1);  
        message = message.div(pairing.pairing(K, ciphertext.C_2));  
        message = message.mul(ciphertext.C_0);  
        Log.i(tag, "Infor - decrypt: the message is " + message);  
        return message;  
    }  
} 

BBGHIBEActivity.java

package cn.edu.buaa.crypto;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class BBGHIBEActivity extends Activity implements View.OnClickListener {
    private static final String tag = "JPBCBenchmarkActivity";
    
    private Button benchmark;

    /**
     * Called when the activity is first created.
     */
    public void onCreate(Bundle savedInstanceState) {
        // Init UI
        super.onCreate(savedInstanceState);
        setContentView(R.layout.bbghibe);

        benchmark = (Button) findViewById(R.id.button);
        benchmark.setOnClickListener(this);
    }

    public void onClick(View view) {
    	if (view == benchmark){
    		TestBBGHIBE.testBBEHIBE();
    	}
    }
}

BBGHIBECiphertext.java

package cn.edu.buaa.crypto;


import it.unisa.dia.gas.jpbc.Element;  

public class BBGHIBECiphertext {  
    Element C_0;  
    Element C_1;  
    Element C_2;  
} 

BBGHIBEMasterKey.java

package cn.edu.buaa.crypto;


import it.unisa.dia.gas.jpbc.Element;  

public class BBGHIBEMasterKey {  
    public Element alpha;  
} 

BBGHIBESecretKey.java

package cn.edu.buaa.crypto;


import it.unisa.dia.gas.jpbc.Element;  

public class BBGHIBESecretKey {  
    public String[] identityVector;  
    public Element K_1;  
    public Element K_2;  
    public Element[] E;  
}  

TestBBGHIBE.java

package cn.edu.buaa.crypto;


import android.util.Log;

public class TestBBGHIBE {  
	private static final String tag = "TestBBGHIBE";
    public static void testBBEHIBE() {  
        BBGHIBE bbgHIBE = new BBGHIBE();  
        BBGHIBEMasterKey msk = bbgHIBE.Setup("assets/a.properties", 7);  
        String[] testI1 = {"Depth 1"};  
        String testI2 = "Depth 2";  
        String testI3 = "Depth 3";  
        String testI4 = "Depth 4";  
        String testI5 = "Depth 5";  
        String testI6 = "Depth 6";  
        String testI7 = "Depth 7";  
        String[] receiver = new String[7];  
        receiver[0] = testI1[0];  
        receiver[1] = testI2;  
        receiver[2] = testI3;  
        receiver[3] = testI4;  
        receiver[4] = testI5;  
        receiver[5] = testI6;  
        receiver[6] = testI7;  
        String[] ciphertextIV = new String[7];  
        System.arraycopy(receiver, 0, ciphertextIV, 0, 7);  
        //KeyGen for depth 1  
        if (BBGHIBE.isDebug){  
            Log.i(tag, "Generate secret key for user at depth 1");  
        }  
        BBGHIBESecretKey SKDepth1 = bbgHIBE.KeyGen(msk, testI1);  
          
        //Delegation for depth 2  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Generate secret key for user at depth 2");  
        }  
        BBGHIBESecretKey SKDepth2 = bbgHIBE.Delegate(SKDepth1, testI2);  
  
        //Delegation for depth 3  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Generate secret key for user at depth 3");  
        }  
        BBGHIBESecretKey SKDepth3 = bbgHIBE.Delegate(SKDepth2, testI3);  
          
        //Delegation for depth 4  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Generate secret key for user at depth 4");  
        }  
        BBGHIBESecretKey SKDepth4 = bbgHIBE.Delegate(SKDepth3, testI4);  
          
        //Delegation for depth 5  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Generate secret key for user at depth 5");  
        }  
        BBGHIBESecretKey SKDepth5 = bbgHIBE.Delegate(SKDepth4, testI5);  
          
        //Delegation for depth 6  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Generate secret key for user at depth 6");  
        }  
        BBGHIBESecretKey SKDepth6 = bbgHIBE.Delegate(SKDepth5, testI6);  
          
        //Delegation for depth 7  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Generate secret key for user at depth 7");  
        }  
        BBGHIBESecretKey SKDepth7 = bbgHIBE.Delegate(SKDepth6, testI7);  
          
        //encryption  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Encryption");  
        }  
        BBGHIBECiphertext ciphertext = bbgHIBE.Encrypt(ciphertextIV);  
          
        //Decryption for depth 1  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Dncryption for user at depth 1");  
        }  
        bbgHIBE.decrypt(ciphertextIV, ciphertext, SKDepth1);  
          
        //Decryption for depth 2  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Dncryption for user at depth 2");  
        }  
        bbgHIBE.decrypt(ciphertextIV, ciphertext, SKDepth2);  
          
        //Decryption for depth 3  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Dncryption for user at depth 3");  
        }  
        bbgHIBE.decrypt(ciphertextIV, ciphertext, SKDepth3);  
          
        //Decryption for depth 4  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Dncryption for user at depth 4");  
        }  
        bbgHIBE.decrypt(ciphertextIV, ciphertext, SKDepth4);  
          
        //Decryption for depth 5  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Dncryption for user at depth 5");  
        }  
        bbgHIBE.decrypt(ciphertextIV, ciphertext, SKDepth5);  
          
        //Decryption for depth 6  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Dncryption for user at depth 6");  
        }  
        bbgHIBE.decrypt(ciphertextIV, ciphertext, SKDepth6);  
          
        //Decryption for depth 7  
        if (BBGHIBE.isDebug){  
        	Log.i(tag, "Dncryption for user at depth 7");  
        }  
        bbgHIBE.decrypt(ciphertextIV, ciphertext, SKDepth7);  
    }  
      
//    public static void main(String[] args){  
//        testBBEHIBE();  
//    }  
}  

Util.java

package cn.edu.buaa.crypto;


import it.unisa.dia.gas.jpbc.Element;  
import it.unisa.dia.gas.jpbc.Pairing;  
  
public class Util {  
    public static Element hash_id(Pairing pairing, String id){  
        byte[] byte_identity = id.getBytes();  
        Element hash = pairing.getZr().newElement().setFromHash(byte_identity, 0, byte_identity.length);  
        return hash;  
    }  
} 

Layout: bbghibe.xml

<?xml version="1.0" encoding="utf-8"?>
<AbsoluteLayout
        android:id="@+id/widget38"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:keepScreenOn="true"
        >

    <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:text="Benchmark"
            android:layout_x="226px"
            android:layout_y="84px"
            >
    </Button>
</AbsoluteLayout>

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="cn.edu.buaa.crypto">

    <application android:icon="@drawable/ic_launcher" android:label="jpbc-benchmark">
        <activity android:name=".BBGHIBEActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
    </application>

</manifest

Android jPBC 2.0.0配置与测试,布布扣,bubuko.com