Erläuterung zu öffentlichem Android-Schlüssel?

Question

Ich bin von diesem guten Rat von http://developer.android.com/guide/google/play/billing/billing_integrate.html#billing-signatures verwirrt

Um Ihren öffentlichen Schlüssel zum Schutz vor böswilligen Benutzern und Hacker zu halten, nicht einbetten Ihren öffentlichen Schlüssel als eine ganze Zeichenkette. Konstruieren Sie stattdessen die Zeichenfolge zur Laufzeit aus Stücken oder verwenden Sie Bit-Manipulation (für Beispiel, XOR mit einer anderen Zeichenfolge), um den tatsächlichen Schlüssel zu verbergen. Der Schlüssel selbst ist keine geheime Information, aber Sie wollen es nicht einfach machen für einen Hacker oder böswilligen Benutzer den öffentlichen Schlüssel durch einen anderen Schlüssel zu ersetzen.

Bedeutet dies, dass

String one = "thisIs"; 
String two = "MyKey"; 
String base64EncodedPublicKey = one + two; 
PublicKey key = Security.generatePublicKey(base64EncodedPublicKey); 
verified = Security.verify(key, signedData, signature); 

sicherer als

ist

String base64EncodedPublicKey = "thisIsMyKey"; 
PublicKey key = Security.generatePublicKey(base64EncodedPublicKey); 
verified = Security.verify(key, signedData, signature); 

? Wenn nicht, könnten Sie mir bitte ein Beispiel dafür geben, wie dies zu tun ist?

Answer 1

Ja. Obwohl Sie in diesem Fall nur Strings verketten, ist das nicht viel besser. Der Grund dafür ist, dass jemand Ihren Code leicht zerlegen und auf Ihren öffentlichen Schlüssel zugreifen kann. Wenn Sie den Schlüssel erneut zusammensetzen müssen, ist es wesentlich schwieriger, den Schlüssel aus dem zerlegten Code zu entnehmen.

Answer 2

Etwas, das eine ernsthafte Änderung des Schlüssels beinhaltet, ist am besten. Persönlich bevorzuge ich Verschlüsselung, so etwas würde funktionieren. Für den Schlüssel, zeichne ein paar Teile zusammen, und es sollte helfen, es zusammen zu bekommen. Verwenden Sie encryptKey, um Ihren Schlüssel zu verschlüsseln, löschen Sie dann den echten Schlüssel aus dem Quellcode, und Sie sollten ziemlich sicher sein. Besser ist es, den Schlüssel von einem sicheren Server zu bekommen, aber das ist nicht immer eine Option.

String encryptKey(String input) 
{ 
    byte[] inBytes=input.getBytes(); 
    String finalString=null; 
    try { 
     Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding"); 
     MessageDigest md = MessageDigest.getInstance("SHA-1"); 
     byte[] keyBytes=md.digest((KeyPart1+KeyPart2).getBytes()); 
     keyBytes = Arrays.copyOf(keyBytes, 16); 
     SecretKey key= new SecretKeySpec(keyBytes,"AES"); 
     IvParameterSpec ivSpec = new IvParameterSpec(new byte[] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}); 
     cipher.init(Cipher.ENCRYPT_MODE,key,ivSpec); 
     byte[] outBytes = new byte[cipher.getOutputSize(inBytes.length)]; 
     //cipher.update(encrypted, 0, encrypted.length, decrypted, 0); 
     outBytes=cipher.doFinal(inBytes); 
     finalString=new String(Base64.encode(outBytes,0)); 
     Log.v(TAG,"Encrypted="+finalString); 

    } catch (NoSuchAlgorithmException e) { 
     Log.e(TAG,"No Such Algorithm",e); 
    } catch (NoSuchPaddingException e) { 
     Log.e(TAG,"No Such Padding",e); 
    } catch (InvalidKeyException e) { 
     Log.e(TAG,"Invalid Key",e); 
    } catch (InvalidAlgorithmParameterException e) { 
     Log.e(TAG,"Invalid Algorithm Parameter",e); 
    } catch (IllegalBlockSizeException e) { 
    } catch (BadPaddingException e) {} 
    return finalString; 
} 

String decryptKey(String base64Text) 
{ 
    byte[] encrypted=Base64.decode(base64Text,0); 
    //encrypted=base64Text.getBytes(); 
    String decryptedString=null; 
    try { 
     Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding"); 
     MessageDigest md = MessageDigest.getInstance("SHA-1"); 
     byte[] keyBytes=md.digest((KeyPart1+KeyPart2).getBytes()); 
     keyBytes = Arrays.copyOf(keyBytes, 16); 
     SecretKey key= new SecretKeySpec(keyBytes,"AES"); 
     IvParameterSpec ivSpec = new IvParameterSpec(new byte[] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}); 
     cipher.init(Cipher.DECRYPT_MODE,key,ivSpec); 
     byte[] decrypted = new byte[cipher.getOutputSize(encrypted.length)]; 
     //cipher.update(encrypted, 0, encrypted.length, decrypted, 0); 
     decrypted=cipher.doFinal(encrypted); 
     decryptedString=new String(decrypted); 
    } catch (NoSuchAlgorithmException e) { 
     logStackTrace(e); 
    } catch (NoSuchPaddingException e) { 
     logStackTrace(e); 
    } catch (InvalidKeyException e) { 
     logStackTrace(e); 
    } catch (InvalidAlgorithmParameterException e) { 
     logStackTrace(e); 
    } catch (IllegalBlockSizeException e) { 
     logStackTrace(e); 
    } catch (BadPaddingException e) { 
     logStackTrace(e); 
    } 
    return decryptedString; 
}