=====new feature added===== Able to run ASHE

conf/CURRENT.conf

@@ -5,8 +5,8 @@
 [onions for num]
 oDET: DETJOIN DET RND
 oOPE: OPE
-oAGG: HOM
-#oASHE: ASHE
+#oAGG: HOM
+oASHE: ASHE
 
 [end]
 

debug/test_ASHE.cc

@@ -75,11 +75,29 @@ void test4() {
     std::cout<<ashe1.decrypt_sum(encsum)<<std::endl;
 }
 
+static
+void test5(){
+    RAW_ASHE ashe1(1);
+    std::pair<long,std::vector<uint64_t>> enc1 = {-997019180l,{15834153223274321377UL}};
+    std::pair<long,std::vector<uint64_t>> enc2 = {873317538l,{4670737221960292774UL}};
+    auto encsum =  ashe1.sum(enc1,enc2);
+    encsum = ashe1.sum(encsum,{-2374120261L,{11932286636268610472UL}});
+    encsum = ashe1.sum(encsum,{3912122192L,{3375502011127705401UL}});
+    encsum = ashe1.sum(encsum,{-329683860,{1422696692650720651}});
+
+    UNUSED(encsum);
+    auto res =  RAW_ASHE::decrypt_sum(encsum);
+    std::cout<<res<<std::endl;
+
+}
+
+
 int main(){
     UNUSED(test1);
     UNUSED(test2);
     test3();
     test4();
+    test5();
     return 0;
 }
 

main/CryptoHandlers.cc

@@ -13,6 +13,7 @@
 
 #include <cmath>
 #include <memory>
+#include <istream>
 
 #define LEXSTRING(cstr) { (char*) cstr, sizeof(cstr) }
 #define BITS_PER_BYTE 8
@@ -1664,19 +1665,51 @@ ASHE::decrypt(const Item &ctext, uint64_t IV) const {
                Item_int(static_cast<ulonglong>(res));
 }
 
+static
+std::vector<std::string>
+split_string(std::string s) {
+    std::vector<std::string> res;
+    int index = 0;
+    int next;
+    while((next=s.find(' ',index))!=-1){
+        res.push_back(s.substr(index,next-index));
+        index = next+1;
+    }
+    res.push_back(s.substr(index));
+    return res;
+}
+
 Item *
 ASHE::decrypt_sum(const Item &ctext) {
-    const std::string plainstr = ItemToString(ctext);
-    std::cout<<"ctext: "<<plainstr<<std::endl;
-    return MySQLFieldTypeToItem(MYSQL_TYPE_STRING, plainstr);
+    std::string plainstr = ItemToString(ctext);
+    while(!(plainstr.back()>='0'&&plainstr.back()<='9')) {
+        plainstr.pop_back();
+    }
+    assert(plainstr.back()!=' ');
+    std::vector<std::string> sum_ivs_vec = split_string(plainstr);
+    long cipher = std::stol(sum_ivs_vec[0]);
+    std::vector<uint64_t> vec;
+    for(unsigned int i = 1;i<sum_ivs_vec.size();i++) {
+        uint64_t value;
+        std::istringstream iss(sum_ivs_vec[i]);
+        iss>>value;
+        vec.push_back(value);
+    }
+    std::pair<long,std::vector<uint64_t>> in = std::make_pair(cipher,vec);
+    uint64_t res = RAW_ASHE::decrypt_sum(in);
+//    return MySQLFieldTypeToItem(MYSQL_TYPE_STRING, plainstr);
+    std::string str = std::to_string(res);
+    return  new (current_thd->mem_root)
+                                Item_int(static_cast<ulonglong>(valFromStr(str)));
 }
 
 
 Item *
-ASHE::sumUDA(Item *const expr) const
+ASHE::sumUDA(Item *const expr,Item *const saltname) const
 {
     List<Item> l;
     l.push_back(expr);
+    l.push_back(saltname);
     return new (current_thd->mem_root) Item_func_udf_str(&u_sumashe_a, l);
 }
 

main/CryptoHandlers.hh

@@ -198,7 +198,7 @@ public:
     Item *encrypt(const Item &p, uint64_t IV) const;
     Item * decrypt(const Item &c, uint64_t IV) const;
     Item * decrypt_sum(const Item &ctext);
-    Item * sumUDA(Item *const expr) const;
+    Item * sumUDA(Item *const expr, Item *const saltname) const;
     
 protected:
     std::string const seed_key;

main/rewrite_main.cc

@@ -919,6 +919,10 @@ decrypt_item_layers(const Item &i, const FieldMeta *const fm, onion o,
     //onionmeta的使用方法很简单, getlayers, 然后层层使用.
     const auto &enc_layers = om->getLayers();
     for (auto it = enc_layers.rbegin(); it != enc_layers.rend(); ++it) {
+        if(o==oASHE) {
+            out_i = ((ASHE&)(*it)).decrypt_sum(*dec);
+            break;
+        }
         out_i = (*it)->decrypt(*dec, IV);
         assert(out_i);
         dec = out_i;

main/rewrite_sum.cc

@@ -206,8 +206,13 @@ class CItemSum : public CItemSubtypeST<Item_sum_sum, SFT> {
             EncLayer const &el = a.getBackEncLayer(*om);
             TEST_UnexpectedSecurityLevel(oASHE, SECLEVEL::ASHE,
                                          el.level());
-            return static_cast<const ASHE &>(el).sumUDA(new_child);
+            const Item_field* old_child =  (Item_field const*)(RiboldMYSQL::get_arg(i, 0));
 
+            const std::string table_name = old_child->table_name;
+            const std::string anno_table_name = a.getTableMeta(a.getDatabaseName(),table_name).getAnonTableName();
+            Item_field * const salt_field = 
+                   make_item_field(*old_child,anno_table_name, constr.key->getSaltName());
+            return static_cast<const ASHE &>(el).sumUDA(new_child,salt_field);
         } else {
             TEST_UnexpectedSecurityLevel(constr.o, SECLEVEL::PLAINVAL,
                                          constr.l);

udf/edb.cc

@@ -582,7 +582,7 @@ my_bool cryptdb_asheagg_add(UDF_INIT *const initid, UDF_ARGS *const args,
     };
     std::pair<long,std::vector<uint64_t>> next = {
         *((long*)args->args[0]),
-        {1},
+        {*((uint64_t*)args->args[1])},
     };
     already = RAW_ASHE::sum(already,next);
     ((ashesumdata*)(initid->ptr))->cipher = already.first;
@@ -597,13 +597,13 @@ char* cryptdb_asheagg(UDF_INIT *const initid, UDF_ARGS *const args,
                       char *const is_null, char *const error) {
     std::string s;
     ashesumdata* data = (ashesumdata*)(initid->ptr);
-    s+=std::to_string(data->cipher)+=std::string("<=cipher ivs=>");
+    s+=std::to_string(data->cipher)+=std::string(" ");
 
     for(auto item:data->IVs) {
         (void)item;
         s+=std::to_string(item)+=std::string(" ");
     }
-    s+=std::string("iv size:")+=std::to_string(data->IVs.size());
+//    s+=std::string("iv size:")+=std::to_string(data->IVs.size());
 
     unsigned int len = s.size();
     *length = len+1;