public static PRE_KEY GenKey( String pk1 , String pk2 , String sk1 , String sk2 )
 {
     PRE_KEY key = new PRE_KEY();
     key.PK = new PRE_PK();
     key.SK = new PRE_SK();
     key.PK.PK1 = pk1;
     key.PK.PK2 = pk2;
     key.SK.X1 = sk1;
     key.SK.X2 = sk2;
     return key;
 }
Esempio n. 2
0
        public Boolean DownloadSharingFile(Protocal.SharingInfo si)
        {
            String copyRef = si.Reference;
            String fileName = si.FileName;
            try
            {
                String dropboxPath = BaseExtension.FileStringHelper.GetNonConflictFileName( Path.Combine( DropBoxController.DropBox_DownloadFolder , fileName ) );

                UserKey uk = PreKeyring.UserKey;
                PRE_KEY userKey = new PRE_KEY();
                userKey.PK.PK1 = uk.PK1;
                userKey.PK.PK2 = uk.PK2;
                userKey.SK.X1 = uk.SK1;
                userKey.SK.X2 = uk.SK2;

                PRE_Cipher CKey = new PRE_Cipher();
                CKey.E = si.CKey_E;
                CKey.F = si.CKey_F;
                CKey.U = si.CKey_U;
                CKey.W = si.CKey_W;

                String key = ProxyReEncryption.KeyDecrypt( userKey , CKey );

                FileMetaData fi = new FileMetaData();
                fi.FileName = fileName;
                fi.FilePath = this.dropBoxController.DropboxSecuruStikFolder2SecuruStikFolder( dropboxPath );
                fi.Key = key;
                fi.PlainTextHash = "";
                fi.CryptTextHash = "";
                PreKeyring.FileInfo_Update( fi );

                String dropboxRemotePath = this.dropBoxController.SecuruStikFolder2RemoteDropboxPath( fi.FilePath );
                this.dropBoxController.CopyAsync( copyRef , dropboxRemotePath );
            }
            catch ( System.Exception ex )
            {
                log.ErrorFormat("DownloadSharingFile {0}", si.FileName, ex);
                PreKeyring.SharingFile_Delete( si.Reference );
                return false;
            }
            return true;
        }
        public static PRE_Cipher KeyEncrypt( PRE_KEY key1 , PRE_PK key2_pk , String m )
        {
            IntPtr pKey1 = ProxyReEncryption.KeyStr2KeyPtr( key1 );
            IntPtr pPk2 = ProxyReEncryption.PKStr2PKPtr( key2_pk );

            IntPtr C = KeyEncrypt( pKey1 , pPk2 , m );
            PRE_Cipher CC = CipherPtr2CipherStr( C );

            return CC;
        }
        private static IntPtr KeyStr2KeyPtr( PRE_KEY key )
        {
            PRE_ptrPK ptrPK = new PRE_ptrPK { pk1 = Marshal.StringToHGlobalAnsi( key.PK.PK1 ) , pk2 = Marshal.StringToHGlobalAnsi( key.PK.PK2 ) };
            IntPtr pPk = Marshal.AllocHGlobal( Marshal.SizeOf( ptrPK ) );
            Marshal.StructureToPtr( ptrPK , pPk , true );

            PRE_ptrSK ptrSK = new PRE_ptrSK { x1 = Marshal.StringToHGlobalAnsi( key.SK.X1 ) , x2 = Marshal.StringToHGlobalAnsi( key.SK.X2 ) };
            IntPtr pSk = Marshal.AllocHGlobal( Marshal.SizeOf( ptrSK ) );
            Marshal.StructureToPtr( ptrSK , pSk , true );

            PRE_ptrKEY keyPtr = new PRE_ptrKEY { pk = pPk , sk = pSk };
            IntPtr pKey = Marshal.AllocHGlobal( Marshal.SizeOf( keyPtr ) );
            Marshal.StructureToPtr( keyPtr , pKey , true );
            return pKey;
        }
 public static String KeyDecrypt( PRE_KEY key2 , PRE_Cipher CC )
 {
     IntPtr pKey2 = KeyStr2KeyPtr( key2 );
     IntPtr C = CipherStr2CipherPtr( CC );
     return KeyDecrypt( pKey2 , C );
 }