recording_by_lab_data_analyzer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5cc4a7ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "import torch\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from torch import nn\n",
    "from tqdm import tqdm\n",
    "from typing import List\n",
    "import multiprocessing as mp\n",
    "import torch.nn.functional as F\n",
    "from collections import defaultdict\n",
    "from random import sample, random, seed\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = \"0\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "818fbddc",
   "metadata": {},
   "outputs": [],
   "source": [
    "set_seed = 42\n",
    "torch.manual_seed(set_seed)\n",
    "torch.cuda.manual_seed(set_seed)\n",
    "torch.cuda.manual_seed_all(set_seed)\n",
    "np.random.seed(set_seed)\n",
    "seed(set_seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e99fe64c",
   "metadata": {},
   "outputs": [],
   "source": [
    "DIM = 50\n",
    "MARGIN = 1\n",
    "BATCH_SIZE = 512\n",
    "TOP_K = 5\n",
    "CORRUPTED_NUM = 100\n",
    "NORM = 2\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5b96fb5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./data/darpa_datasets/data/recording_by_lab/benign.json','rb') as f:\n",
    "    benign = json.load(f)\n",
    "    benign = benign['benign']\n",
    "with open('./data/darpa_datasets/data/recording_by_lab/CALDERA_malicious.json','rb') as f:\n",
    "    malicious = json.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "59644118",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 70084/70084 [00:00<00:00, 1692618.11it/s]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "object_'s key should not be in ['type','pid','srcip', 'srcport', 'protocol', 'type'], 英仁說的\n",
    "values of object_:'dstip' and object_:'dstport' should be concatenated, 英仁說的\n",
    "I choose cmdline from subject's keys and object_'s keys, so image is removed from object_.\n",
    "'''\n",
    "temp = []\n",
    "filter_ls = ['type','image','pid','srcip', 'srcport', 'protocol', 'type']\n",
    "for i,(subject,relation,object_) in tqdm(enumerate(benign),total=len(benign)):\n",
    "    if benign[i][subject]['cmdline'] != None and benign[i][relation] != None:\n",
    "        filtered_object = list(filter(lambda x: x[0] not in filter_ls,benign[i][object_].items()))\n",
    "        object_data = ':'.join([str(y) for x,y in filtered_object])\n",
    "        temp.append([\n",
    "            benign[i][subject]['cmdline'], benign[i][relation], object_data, 'benign'\n",
    "        ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "83d167e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 69/69 [00:00<00:00, 7990.03it/s]\n"
     ]
    }
   ],
   "source": [
    "filter_ls = ['type','image','pid','srcip', 'srcport', 'protocol', 'type']\n",
    "for key,values in tqdm(malicious.items(),total=len(malicious.items())):\n",
    "    for value in values:\n",
    "        for i,(subject,relation,object_) in enumerate(value['audit log']):\n",
    "            if value['audit log'][i][subject]['cmdline'] != None and value['audit log'][i][relation] != None:\n",
    "                filtered_object = list(filter(lambda x: x[0] not in filter_ls,benign[i][object_].items()))\n",
    "                object_data = ':'.join([str(y) for x,y in filtered_object])\n",
    "                temp.append([\n",
    "                    value['audit log'][i][subject]['cmdline'], value['audit log'][i][relation], object_data, value['TTP']\n",
    "                ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "aee98d95",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(temp,columns=['Subject','relation','Object','malicious_or_benign'])\n",
    "train_df, valid_df = train_test_split(df, test_size=0.2,random_state=42,shuffle=True)\n",
    "valid_df, test_df = train_test_split(valid_df, test_size=0.5,random_state=42,shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7fada83e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# df = pd.read_csv('./transE_data.csv')\n",
    "# with open('./data/freebase_mtr100_mte100-train.txt','r') as f:\n",
    "#     temp = np.array([i.split() for i in f.readlines()])\n",
    "#     train_df = pd.DataFrame(temp,columns=['Subject','relation','Object'])\n",
    "# with open('./data/freebase_mtr100_mte100-valid.txt','r') as f:\n",
    "#     temp = np.array([i.split() for i in f.readlines()])\n",
    "#     valid_df = pd.DataFrame(temp,columns=['Subject','relation','Object'])\n",
    "# with open('./data/freebase_mtr100_mte100-test.txt','r') as f:\n",
    "#     temp = np.array([i.split() for i in f.readlines()])\n",
    "#     test_df = pd.DataFrame(temp,columns=['Subject','relation','Object'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5ffc4f79",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = list(set(train_df['Subject']) | set(train_df['Object']))\n",
    "subj_obj_dic = dict(zip(data,range(len(data))))\n",
    "data = list(set(train_df['relation']))\n",
    "relation_dic = dict(zip(data,range(len(data))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d68262f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Create']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ff845c7c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/workdir/security/home/junjiehuang2468/.local/lib/python3.6/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n",
      "/workdir/security/home/junjiehuang2468/.local/lib/python3.6/site-packages/ipykernel_launcher.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \n",
      "/workdir/security/home/junjiehuang2468/.local/lib/python3.6/site-packages/ipykernel_launcher.py:3: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "train_df['Subject'] = train_df['Subject'].map(lambda x: subj_obj_dic.get(x,len(subj_obj_dic)))\n",
    "train_df['Object'] = train_df['Object'].map(lambda x: subj_obj_dic.get(x,len(subj_obj_dic)))\n",
    "train_df['relation'] = train_df['relation'].map(lambda x: relation_dic.get(x,len(relation_dic)))\n",
    "\n",
    "valid_df['Subject'] = valid_df['Subject'].map(lambda x: subj_obj_dic.get(x,len(subj_obj_dic)))\n",
    "valid_df['Object'] = valid_df['Object'].map(lambda x: subj_obj_dic.get(x,len(subj_obj_dic)))\n",
    "valid_df['relation'] = valid_df['relation'].map(lambda x: relation_dic.get(x,len(relation_dic)))\n",
    "\n",
    "test_df['Subject'] = test_df['Subject'].map(lambda x: subj_obj_dic.get(x,len(subj_obj_dic)))\n",
    "test_df['Object'] = test_df['Object'].map(lambda x: subj_obj_dic.get(x,len(subj_obj_dic)))\n",
    "test_df['relation'] = test_df['relation'].map(lambda x: relation_dic.get(x,len(relation_dic)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4794fc7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransE_Model(nn.Module):\n",
    "    def __init__(self,entity_num:int,relation_num:int,embedding_dim:int,NORM:int=1):\n",
    "        super().__init__()\n",
    "        self.NORM = NORM\n",
    "        self.entity_num = entity_num\n",
    "        self.relation_num = relation_num\n",
    "        self.embedding_dim = embedding_dim\n",
    "        self.entity_embedding = self.generate_embedding(self.entity_num)\n",
    "        self.relation_embedding = self.generate_embedding(self.relation_num)\n",
    "        self.relation_embedding = self.normalize_embedding(self.relation_embedding)\n",
    "    \n",
    "    def generate_embedding(self,num):\n",
    "        emb = nn.Embedding(num_embeddings=num+1,embedding_dim=self.embedding_dim,padding_idx=num)\n",
    "        emb.weight.data.uniform_(-6/(self.embedding_dim**0.5),6/(self.embedding_dim**0.5))\n",
    "        return emb\n",
    "    \n",
    "    def normalize_embedding(self,emb):\n",
    "        emb.weight.data /= emb.weight.data.norm(p=self.NORM,dim=1,keepdim=True)\n",
    "        return emb\n",
    "    \n",
    "    def forward(self,subject,relation,object_):\n",
    "        x = self.entity_embedding(subject)\n",
    "        x += self.relation_embedding(relation)\n",
    "        x -= self.entity_embedding(object_)\n",
    "        return x.norm(p=self.NORM,dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d7b49474",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Custom_Dataset(Dataset):\n",
    "    def __init__(self,df:pd.DataFrame):\n",
    "        super().__init__()\n",
    "        self.data = [tuple(i) for i in df.values]\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    def __getitem__(self,idx):\n",
    "        return self.data[idx]\n",
    "\n",
    "class Generate_Corrupted_Triple():\n",
    "    def __init__(self,df:pd.DataFrame):\n",
    "        self.obj = set(df['Object'])\n",
    "        self.subj = set(df['Subject'])\n",
    "        self.s_2_o_dic, self.o_2_s_dic = self.generate_dic(df)\n",
    "    def generate_dic(self,df):\n",
    "        s_2_o_dic = defaultdict(set)\n",
    "        o_2_s_dic = defaultdict(set)\n",
    "        for s,r,o,b_or_m in df.values:\n",
    "            s_2_o_dic[s].add(o)\n",
    "            o_2_s_dic[o].add(s)\n",
    "        return s_2_o_dic,o_2_s_dic\n",
    "    def __call__(self,subject,relation,object_):\n",
    "        new_subject = torch.tensor([sample(self.subj - self.o_2_s_dic[obj],k=1)[0] for obj in object_.cpu().numpy()])\n",
    "        new_object = torch.tensor([sample(self.obj - self.s_2_o_dic[subj],k=1)[0] for subj in subject.cpu().numpy()])\n",
    "        return [new_subject,relation,object_],[subject,relation,new_object]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0fea4876",
   "metadata": {},
   "outputs": [],
   "source": [
    "def To_Device(batch,device):\n",
    "    return [b.to(device) for b in batch]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "13d15922",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = TransE_Model(\n",
    "    entity_num=len(set(train_df['Subject']) | set(train_df['Object'])),\n",
    "    relation_num=len(set(train_df['relation'])),\n",
    "    embedding_dim=DIM,NORM=NORM\n",
    ").to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7bebb09f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# train, test = train_test_split(df, test_size=0.2)\n",
    "train_dataset = Custom_Dataset(train_df)\n",
    "train_dataloader = DataLoader(train_dataset,batch_size=BATCH_SIZE,shuffle=True)\n",
    "valid_dataset = Custom_Dataset(valid_df)\n",
    "valid_dataloader = DataLoader(valid_dataset,batch_size=16,shuffle=False)\n",
    "test_dataset = Custom_Dataset(test_df)\n",
    "test_dataloader = DataLoader(test_dataset,batch_size=len(test_dataset),shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3e688264",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model,train_dataloader,loss_fn,optim_fn,device):\n",
    "    losses = []\n",
    "    bar = tqdm(enumerate(train_dataloader),total=len(train_dataloader))\n",
    "    target = torch.tensor([-1], dtype=torch.long, device=device)\n",
    "    for idx,batch in bar: \n",
    "        model.entity_embedding = model.normalize_embedding(model.entity_embedding)\n",
    "        corrupted_batch_1,corrupted_batch_2 = GCT(*batch[:3])\n",
    "        loss = 0.5*loss_fn(\n",
    "            model(*To_Device(batch[:3],device)),model(*To_Device(corrupted_batch_1,device)),target\n",
    "        ) + 0.5*loss_fn(\n",
    "            model(*To_Device(batch[:3],device)),model(*To_Device(corrupted_batch_2,device)),target\n",
    "        )\n",
    "        # if random() > 0.5:\n",
    "        #     loss = loss_fn(\n",
    "        #         model(*To_Device(batch,device)),model(*To_Device(corrupted_batch_1,device)),target\n",
    "        #     )\n",
    "        # else:\n",
    "        #     loss = loss_fn(\n",
    "        #         model(*To_Device(batch,device)),model(*To_Device(corrupted_batch_2,device)),target\n",
    "        #     )\n",
    "        optim_fn.zero_grad()\n",
    "        loss.backward()\n",
    "        optim_fn.step()\n",
    "        losses.append(loss.item())\n",
    "        bar.set_description(f'loss: {np.mean(losses):8.7f}')\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f5bd33c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def valid(model,dataloader,device,TOP_K):\n",
    "    top_k = []\n",
    "    bar = tqdm(dataloader)\n",
    "    for batch in bar:\n",
    "        subject,relation,object_ = To_Device(batch[:3],device)\n",
    "        temp = model.entity_embedding(subject)\n",
    "        temp += model.relation_embedding(relation)\n",
    "        # temp -= model.entity_embedding(object_)\n",
    "\n",
    "        shape = temp.shape\n",
    "        temp = temp.unsqueeze(1)\n",
    "        temp = temp.expand(shape[0],len(model.entity_embedding.weight),shape[1])\n",
    "\n",
    "        entity_weight = model.entity_embedding.weight.unsqueeze(0)\n",
    "        entity_weight = entity_weight.expand(shape[0],len(model.entity_embedding.weight),shape[1]).to(device)\n",
    "\n",
    "        values,indices = torch.topk((temp - entity_weight).norm(p=NORM,dim=2),k=TOP_K,largest=False)\n",
    "        top_k.append(torch.eq(indices , batch[2].unsqueeze(1).to(device)).float().sum().item()/len(batch[0]))\n",
    "        bar.set_description(f'top_{TOP_K}: {np.mean(top_k):8.7f}')\n",
    "    return np.mean(top_k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a5742e8f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model = torch.load('./models/reording_by_lab_data/epoch_99_top_5_0.625.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "cb3acdbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.manifold import TSNE\n",
    "PLOT_NUM = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "27d308e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "tsne_model = TSNE(n_components=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "54da64e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1/1 [00:00<00:00, 84.54it/s]\n"
     ]
    }
   ],
   "source": [
    "embeddings = []\n",
    "bar = tqdm(enumerate(test_dataloader),total=len(test_dataloader))\n",
    "target = torch.tensor([-1], dtype=torch.long, device=device)\n",
    "for idx,batch in bar: \n",
    "    benign_or_malicious = batch[-1][:PLOT_NUM]\n",
    "    batch = To_Device(batch[:3],device)\n",
    "    x = model.entity_embedding(batch[0][:PLOT_NUM])\n",
    "    x += model.relation_embedding(batch[1][:PLOT_NUM])\n",
    "    x -= model.entity_embedding(batch[2][:PLOT_NUM])\n",
    "    embeddings.extend(x.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c960bbfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "compress_embedding = tsne_model.fit_transform(embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a4aa4a31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15,10))\n",
    "plt.scatter(compress_embedding[:,0],compress_embedding[:,1],s=10)\n",
    "for idx,(x,y,key) in enumerate(zip(compress_embedding[:,0],compress_embedding[:,1],benign_or_malicious)):\n",
    "    plt.text(x,y,','.join([str(idx),key]),ha='left',rotation=0,c='black' if key != 'benign' else 'red',fontsize=8)\n",
    "    # plt.text(x,y,key,ha='left',rotation=0,c='black' if key != 'benign' else 'red',fontsize=8)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "29d9d98d",
   "metadata": {},
   "outputs": [],
   "source": [
    "sub,rel,obj = batch[0].tolist(),batch[1].tolist(),batch[2].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "57bb0ddd",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_subj_obj_dic = {j:i for i,j in subj_obj_dic.items()}\n",
    "r_relation_dic = {j:i for i,j in relation_dic.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "267a2578",
   "metadata": {},
   "outputs": [],
   "source": [
    "sub = [r_subj_obj_dic.get(i,'OOV') for i in sub]\n",
    "rel = [r_relation_dic.get(i,'OOV') for i in rel]\n",
    "obj = [r_subj_obj_dic.get(i,'OOV') for i in obj]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "5aafe732",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(zip(sub,rel,obj,benign_or_malicious),columns=['subject','relation','object','type']).to_csv('./recording_by_lab_data.csv',index=True)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}