limited version of ASHE that is able to decrypt and sum

crypto/ASHE.cc

-#include"crypto/ASHE.hh"
-const unsigned long ASHE::ASHE_MAX = 0xffffffffffffffff;
+#include "crypto/ASHE.hh"
+#include <iostream>
+const unsigned int ASHE::ASHE_MAX = 0xffffffff;
 const std::string ASHE::key("11223344");
 blowfish ASHE::bf(ASHE::key);
 
-
 ASHE::ASHE(int i):IV(i){
 }
 
-std::pair<long,uint64_t> ASHE::encrypt(unsigned long plaintext){
-    ciphertext = (plaintext - Fi(IV) + Fi_1(IV))%ASHE_MAX;
+std::pair<long,uint64_t> ASHE::encrypt(unsigned int plaintext){
+    uint64_t i = Fi(IV)%ASHE_MAX, i_1=Fi_1(IV)%ASHE_MAX;    
+    long res = (long)i_1 - (long)i;
+    ciphertext = ((long)plaintext + res)%ASHE_MAX;
     return std::make_pair(ciphertext,IV);
 }
 
-unsigned long ASHE::decrypt(long ciphertext){
-    return (ciphertext +  Fi(IV) - Fi_1(IV))%ASHE_MAX;
+unsigned int ASHE::decrypt(long ciphertext){
+    uint64_t i = Fi(IV)%ASHE_MAX, i_1=Fi_1(IV)%ASHE_MAX;
+    long res = (long)i - (long)i_1;
+    return (ciphertext + res)%ASHE_MAX;
 }
 
-
-
 std::pair<long,std::vector<uint64_t>> ASHE::sum(std::vector<ASHE> input){
     long res=0;
     std::vector<uint64_t> ivs;
     for(auto &item:input){
-        res += item.get_ciphertext();
+        long cph = item.get_ciphertext();
+        res += cph;
         res %= ASHE_MAX;
         ivs.push_back(item.get_IV());
     }
@@ -30,9 +33,11 @@ std::pair<long,std::vector<uint64_t>> ASHE::sum(std::vector<ASHE> input){
 }
 
 uint64_t ASHE::decrypt_sum(std::pair<long,std::vector<uint64_t>> input){
-    uint64_t res = input.first;
+    long res = input.first;
     for(auto item:input.second){
-        res += (Fi(item) - Fi_1(item));
+        uint64_t i = Fi(item)%ASHE_MAX, i_1=Fi_1(item)%ASHE_MAX;
+        long target = (long)i - (long)i_1;
+        res += target;
         res %= ASHE_MAX;
     }
     return res;

crypto/ASHE.hh

@@ -4,22 +4,23 @@
 #include "crypto/blowfish.hh"
 
 class ASHE{
-    static const unsigned long ASHE_MAX;
+    static const unsigned int ASHE_MAX;/*n*/
     static const std::string key;
     static blowfish bf;
     uint64_t IV;
     long ciphertext;
 public:
+    ASHE(int iv);
 
-    static uint64_t Fi(uint64_t IV){return bf.encrypt(IV);}
-    static uint64_t Fi_1(uint64_t IV){return bf.encrypt(IV-1);}
     long get_ciphertext(){return ciphertext;}
-    ASHE(int iv);
 
-    std::pair<long,uint64_t> encrypt(unsigned long plaintext);
+
+    std::pair<long,uint64_t> encrypt(unsigned int plaintext);
+    unsigned int decrypt(long ciphertext);
     uint64_t get_IV(){return IV;};
-    unsigned long decrypt(long ciphertext);
-    
+
+    static uint64_t Fi(uint64_t IV){return bf.encrypt(IV)%100000;}
+    static uint64_t Fi_1(uint64_t IV){return bf.encrypt(IV-1)%100000;}
     static std::pair<long,std::vector<uint64_t>> sum(std::vector<ASHE>);
     static uint64_t decrypt_sum(std::pair<long,std::vector<uint64_t>>);
 };

debug/test_ASHE.cc

@@ -2,25 +2,25 @@
 #include <iostream>
 #include "crypto/ASHE.hh"
 #include "util/util.cc"
-
 int main(){
-    std::vector<unsigned long long > plain{1u,2u,3u//,4u,5u,6u,7u,8u,9u,10u
-                                          };
+    const int num_of_tests = 100;
+    unsigned int seed = 1u;
+    std::vector<unsigned int> plain;
     std::vector<ASHE> ass;
-    for(auto item:plain){
+    for(int i=0;i<num_of_tests;i++){
+        plain.push_back(seed);
         uint64_t IV = randomValue();
         if(IV==0) IV=1;
         ass.push_back(ASHE(IV));
-        ass.back().encrypt(item);
-    }
-    
-    for(auto &item:ass){
-        std::cout<<item.get_ciphertext()<<"::"<<item.decrypt(item.get_ciphertext())<<std::endl;
+        ass.back().encrypt(seed);
+        unsigned int res = ass.back().decrypt(ass.back().get_ciphertext());
+        if(res==seed) std::cout<<"pass"<<std::endl;
+        else std::cout<<"not pass!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<std::endl;
+        seed++;
     }
 
     std::pair<long,std::vector<uint64_t>> enc_sum = ASHE::sum(ass);
-
-    uint64_t res = ASHE::decrypt_sum(enc_sum);
+    long res = ASHE::decrypt_sum(enc_sum);
     std::cout<<enc_sum.first<<"::"<<res<<std::endl;
     return 0;
 }