init

SugamKuber · web-flow · commit 7c27c0d86d2b · 2024-07-10T02:10:27.000+05:30
diff --git a/Cargo.toml b/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "data_storage"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+aes-gcm = "0.10.1"
+rand = "0.8.5"
+chrono = { version = "0.4", features = ["serde"] }
+serde = { version = "1.0", features = ["derive"] }
+bincode = "1.3"
diff --git a/LICENSE b/LICENSE
diff --git a/README.md b/README.md
@@ -0,0 +1,20 @@
+# IntelliLog-Database
+Database for IntelliLog Open Source Project 
+
+
+# Docs
+
+- We are storing all the data in ```.itlg``` custom file format made for IntelliLog Project, Pronounce as "It Log"
+
+### Usage
+- ```cargo build``` for building
+- ```cargo run write myFileName "header" "body"``` for writing into itlg db
+- ```cargo run read myFileName``` for reading itlg db
+
+### Note
+- Data Format ```TIME HEADER BODY```
+- The project is still under development, The above are subjected to change
+
+### Contributors
+
+**Creator/Founder**: Sugam Kuber ([Github](https://github.com/sugamkuber)) ([LinkedIn](https://linkedin.com/in/sugamkuber))
diff --git a/src/helper/crypto.rs b/src/helper/crypto.rs
@@ -0,0 +1,27 @@
+use aes_gcm::{
+    aead::{Aead, KeyInit, OsRng},
+    Aes256Gcm, Nonce
+};
+use rand::Rng;
+
+pub fn encrypt(data: &[u8], key: &[u8; 32]) -> Vec<u8> {
+    let cipher = Aes256Gcm::new_from_slice(key).unwrap();
+    let nonce_bytes = random_nonce();
+    let nonce = Nonce::from_slice(&nonce_bytes);
+    let ciphertext = cipher.encrypt(nonce, data).unwrap();
+    [&nonce_bytes[..], &ciphertext].concat()
+}
+
+pub fn decrypt(encrypted_data: &[u8], key: &[u8; 32]) -> Option<Vec<u8>> {
+    if encrypted_data.len() < 12 {
+        return None;
+    }
+    let (nonce, ciphertext) = encrypted_data.split_at(12);
+    let cipher = Aes256Gcm::new_from_slice(key).unwrap();
+    cipher.decrypt(Nonce::from_slice(nonce), ciphertext).ok()
+}
+
+fn random_nonce() -> [u8; 12] {
+    let mut rng = OsRng;
+    rng.gen()
+}
diff --git a/src/main.rs b/src/main.rs
@@ -0,0 +1,49 @@
+mod ops {
+    pub mod read;
+    pub mod write;
+}
+
+mod helper {
+    pub mod crypto;
+}
+
+use std::env;
+use std::io;
+
+fn main() -> io::Result<()> {
+    let args: Vec<String> = env::args().collect();
+    
+    // This should be securely stored and retrieved in a real application
+    let key: [u8; 32] = [1; 32];  // Example key, don't use this in production!
+
+    if args.len() < 3 {
+        eprintln!("Usage: {} [write <filename> <headers> <body> | read <filename>]", args[0]);
+        return Ok(());
+    }
+
+    match args[1].as_str() {
+        "write" => {
+            if args.len() != 5 {
+                eprintln!("Usage: {} write <filename> <headers> <body>", args[0]);
+            } else {
+                let filename = format!("{}.itlg", args[2]);
+                let headers = args[3].clone();
+                let body = args[4].clone();
+                ops::write::write_record(&filename, headers, body, &key)?;
+            }
+        },
+        "read" => {
+            if args.len() != 3 {
+                eprintln!("Usage: {} read <filename>", args[0]);
+            } else {
+                let filename = format!("{}.itlg", args[2]);
+                ops::read::read_records(&filename, &key)?;
+            }
+        },
+        _ => {
+            eprintln!("Unknown command: {}", args[1]);
+        }
+    }
+
+    Ok(())
+}
diff --git a/src/ops/read.rs b/src/ops/read.rs
@@ -0,0 +1,44 @@
+use std::fs::File;
+use std::io::{self, BufReader, Read, Seek, SeekFrom};
+use chrono::prelude::*;
+use serde::{Serialize, Deserialize};
+use bincode;
+use crate::helper::crypto;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct DataRecord {
+    pub time: DateTime<Utc>,
+    pub headers: String,
+    pub body: String,
+}
+
+pub fn read_records(filename: &str, key: &[u8; 32]) -> io::Result<()> {
+    let mut file = File::open(filename)?;
+    let file_len = file.metadata()?.len();
+    let mut position = 0;
+
+    while position < file_len {
+        file.seek(SeekFrom::Start(position))?;
+        let mut reader = BufReader::new(&file);
+        let mut size_buffer = [0u8; 4];
+
+        reader.read_exact(&mut size_buffer)?;
+        let size = u32::from_be_bytes(size_buffer) as usize;
+
+        let mut encrypted_buffer = vec![0u8; size];
+        reader.read_exact(&mut encrypted_buffer)?;
+
+        if let Some(decrypted) = crypto::decrypt(&encrypted_buffer, key) {
+            match bincode::deserialize::<DataRecord>(&decrypted) {
+                Ok(record) => println!("{:?}", record),
+                Err(e) => eprintln!("Error deserializing record: {}", e),
+            }
+        } else {
+            eprintln!("Error decrypting record");
+        }
+
+        position += 4 + size as u64;
+    }
+
+    Ok(())
+}
diff --git a/src/ops/write.rs b/src/ops/write.rs
@@ -0,0 +1,52 @@
+use std::fs::{OpenOptions};
+use std::io::{self, Write, Read, Seek, SeekFrom};
+use chrono::prelude::*;
+use serde::{Serialize, Deserialize};
+use bincode;
+use crate::helper::crypto;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct DataRecord {
+    pub time: DateTime<Utc>,
+    pub headers: String,
+    pub body: String,
+}
+
+impl DataRecord {
+    pub fn new(headers: String, body: String) -> Self {
+        Self {
+            time: Utc::now(),
+            headers,
+            body,
+        }
+    }
+}
+
+pub fn write_record(filename: &str, headers: String, body: String, key: &[u8; 32]) -> io::Result<()> {
+    let record = DataRecord::new(headers, body);
+    let mut file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .open(filename)?;
+
+    let encoded: Vec<u8> = bincode::serialize(&record).unwrap();
+    let encrypted = crypto::encrypt(&encoded, key);
+    let new_record = (encrypted.len() as u32).to_be_bytes().to_vec();
+    let new_record = [new_record, encrypted].concat();
+
+    // Read existing content
+    let mut existing_content = Vec::new();
+    file.read_to_end(&mut existing_content)?;
+
+    // Move file cursor to the beginning
+    file.seek(SeekFrom::Start(0))?;
+
+    // Write new record followed by existing content
+    file.write_all(&new_record)?;
+    file.write_all(&existing_content)?;
+    file.set_len(new_record.len() as u64 + existing_content.len() as u64)?;
+    file.flush()?;
+
+    Ok(())
+}
