codage.java

RSA is an asymetric method to crypt message. You can use RSA to crypt the key session of symetric me

package rsa;


public class Codage {
    
    public static String EME_OAEP_Coding(String M,String L,int k,int mLen){
        int hLen=20;
        int tmp=k-mLen-2*hLen-2;
        sha1 sh=new sha1(L,16);
        int[]sha=sh.getHash();
        String lHash="";
        for(int i=0;i<5;i++)lHash=lHash+completeparzero(Long.toHexString(sha[4-i] & 0xFFFFFFFFL),8);
        String PS="";
        for(int i=0;i<tmp;i++)PS=PS+"00";
        String DB = lHash +PS + "01" + M ;
        String seed=generateSeed(hLen);
        
        String dbMask = MGF.getMGF(seed,k-hLen-1);

        String maskedDB = xOr(DB,dbMask);
        
        String seedMask = MGF.getMGF(maskedDB,hLen);
        String maskedSeed = xOr(seed,seedMask);
        String EM = "00" +maskedSeed +maskedDB;
        return EM;
    }
    
    public static String EME_OAEP_Decoding(String EM,String L,int k){
        int hLen=20;
        String M="";
        sha1 sh=new sha1(L,16);
        int[]sha=sh.getHash();
        String lHash="";
        for(int i=0;i<5;i++)lHash=lHash+completeparzero(Long.toHexString(sha[4-i] & 0xFFFFFFFFL),8);
        String Y=EM.substring(0,2);
        String maskedSeed=EM.substring(2,2+2*hLen);
        String maskedDB=EM.substring(2+2*hLen);
        
        String seedMask = MGF.getMGF(maskedDB,hLen);
        String seed = xOr(maskedSeed,seedMask);
        
        String dbMask = MGF.getMGF(seed,k-hLen-1);
        String DB = xOr(maskedDB,dbMask);
        String lHashprime=DB.substring(0,2*hLen);        
        String PS="";
        int deb=2*hLen;
        while(deb<DB.length()){
            if(DB.substring(deb,deb+2).equals("01"))break;
            else if(DB.substring(deb,deb+2).equals("00")){
                PS="00"+PS;
                deb+=2;
            }else{
                return "Erreur";
            }
        }
        deb+=2;
        if(deb<DB.length()){
            M=DB.substring(deb);
        }else{
            return "Erreur";
        }
        if(lHash.equals(lHashprime) && Y.equals("00")){
            return M;
        }else{
            return "Erreur";
        }
    }       
   
    
    private static String xOr(String str1,String str2){
        int str1_len=str1.length()/2;
        String str="";
        for(int i=0;i<str1_len;i++){
            str=str+completeparzero(Integer.toHexString(Integer.parseInt(str1.substring(2*i,2*i+2), 16)^Integer.parseInt(str2.substring(2*i,2*i+2), 16)),2);
        }
        return str;
    }
    
    public static String EMSA_PSS_ENCODE (String M, int emBits,int sLen){
        int hLen=20;
        int emLen=(int)((emBits+7)/8);
        sha1 sh=new sha1(M,16);
        int[]sha=sh.getHash();
        String mHash="";
        for(int i=0;i<5;i++)mHash=mHash+completeparzero(Long.toHexString(sha[4-i] & 0xFFFFFFFFL),8);
        String salt=generateSeed(sLen);
        String Mprime = "0000000000000000"+mHash+salt;
        sh=new sha1(Mprime,16);
        sha=sh.getHash();
        String H="";
        for(int i=0;i<5;i++)H=H+completeparzero(Long.toHexString(sha[4-i] & 0xFFFFFFFFL),8);
        int tmp=emLen-sLen-hLen-2;
        String PS="";
        for(int i=0;i<tmp;i++)PS=PS+"00";
        String DB=PS+"01"+salt;
        String dbMask = MGF.getMGF(H,emLen-hLen-1);
        String maskedDB = xOr(DB,dbMask);
        int gauche=Integer.parseInt(maskedDB.substring(0,2),16);
        tmp=8*emLen-emBits;
        gauche=gauche<<tmp;
        gauche=gauche & 0xff;
        gauche=gauche>>>tmp;
        maskedDB=Integer.toHexString(gauche)+maskedDB.substring(2);
        String EM=maskedDB+H+"bc";
        return EM;
    }
    
    public static String EMSA_PSS_VERIFY(String M,String EM,int emBits,int sLen){
        int emLen=EM.length()/2;
        int hLen=20;
        sha1 sh=new sha1(M,16);
        int[]sha=sh.getHash();
        String mHash="";
        for(int i=0;i<5;i++)mHash=mHash+completeparzero(Long.toHexString(sha[4-i] & 0xFFFFFFFFL),8);
        if(emLen<hLen+sLen+2)return "inconsistent1";
        if(!EM.substring(2*(emLen-1)).equals("bc"))return "inconsistent2";
        String maskedDB=EM.substring(0,2*(emLen-hLen-1));
        String H=EM.substring(2*(emLen-hLen-1),2*(emLen-1));
        int gauche=Integer.parseInt(maskedDB.substring(0,2),16);
        int tmp=8-8*emLen+emBits;
        gauche=gauche>>>tmp;
        if(gauche != 0)return "inconsistent3";
        String dbMask = MGF.getMGF(H,emLen-hLen-1);
        String DB = xOr(maskedDB,dbMask);
        gauche=Integer.parseInt(DB.substring(0,2),16);
        tmp=8*emLen-emBits;
        gauche=gauche<<tmp;
        gauche=gauche & 0xff;
        gauche=gauche>>>tmp;
        DB=completeparzero(Integer.toHexString(gauche),2)+DB.substring(2);
        gauche=Integer.parseInt(DB.substring(0,2*(emLen-hLen-sLen-2)),16);
        if(gauche!=0)return "inconsistent4";
        int zero_un=Integer.parseInt(DB.substring(2*(emLen-hLen-sLen-2),2*(emLen-hLen-sLen-1)),16);
        if(zero_un!=1)return "inconsistent5";
        String salt=DB.substring(DB.length()-2*sLen);
        String Mprime="0000000000000000"+mHash+salt;
        sh=new sha1(Mprime,16);
        sha=sh.getHash();
        String Hprime="";
        for(int i=0;i<5;i++)Hprime=Hprime+completeparzero(Long.toHexString(sha[4-i] & 0xFFFFFFFFL),8);
        if(H.equals(Hprime))return "consistent";
        else return "inconsistent6";
        
    }
    
    private static String completeparzero(String str,int len){
        if(str.length()<len){
            int str_len=str.length();
            for(int i=0;i<len-str_len;i++)str="0"+str;
        }
        return str;
    }
    
    private static String generateSeed(int len){
        String seed="";
        for(int i=0;i<len;i++)seed=seed+completeparzero(Integer.toHexString((int)(256*Math.random())),2);
        return seed;
    }
        
}