diff --git a/git-encrypt/Git-craft v0.1.0 Design Document.docx b/git-encrypt/Git-craft v0.1.0 Design Document.docx
new file mode 100644
index 0000000000000000000000000000000000000000..8d71b35d6ec350a018c72382272d332b2865f40f
Binary files /dev/null and b/git-encrypt/Git-craft v0.1.0 Design Document.docx differ
diff --git a/git-encrypt/craft/.gitignore b/git-encrypt/craft/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..18208ad1e13fc4f8eab5d9bf9d98a34d9dc74604
--- /dev/null
+++ b/git-encrypt/craft/.gitignore
@@ -0,0 +1,9 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+#craft keys
+key_files/*
+
+#filter config
+.gitattributes
\ No newline at end of file
diff --git a/git-encrypt/craft/Cargo.toml b/git-encrypt/craft/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1b17dddc3fc7bd8f3f5e6f31323fb5bcb4e4d6e6
--- /dev/null
+++ b/git-encrypt/craft/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "git-craft"
+version = "0.1.0"
+edition = "2021"
+
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[workspace]
+
+[dependencies]
+anyhow = "1.0.69"
+pgp = "0.10.2"
+rand = "0.8.5"
+smallvec = "1.10.0"
+clap = { version = "4.3.0", features = ["derive"] }
+
diff --git a/git-encrypt/craft/README.md b/git-encrypt/craft/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8b544bdf62b64080252f3704acd657cb8f710707
--- /dev/null
+++ b/git-encrypt/craft/README.md
@@ -0,0 +1,45 @@
+# Git-craft v0.1.0
+
+Git-craft is a extension for git, it can encrypt the content when submitting code in Git, and rewrite the content of the Blob object and code decryption when reading the Blob content, with filter.
+
+## Prepare
+1. cd mega/craft
+2. modify all the key file path, KEY_FILE_PATH, MSG_FILE_NAME and filter to match your project
+3. cargo build --release
+
+## Usage
+
+1. git-craft generate-key
+  - git-craft will default generate a public key to /key_files/pub.asc and a secret key to /key_files/sec.asc
+2. git-craft generate-key-full [primary_id] [key_name]
+  - git-craft will generate key with primary id and key name you entered to default file path
+3. git-craft encrypt [public_key_path]
+  - git-craft will get the file content and encrypt it, it should be used without public key path now, because I set a default key path
+4. git-craft decrypt [secret_key_path]
+  - git-craft will decrypt blob data read from git's standard input stream, it should be used without secret key path now, because I set a default key path
+5. git-craft list-keys [Option<key_path>]
+  - git-craft will list keys name, key's fingerprint and id, it should be used without key path now, because I set a default key path
+6. git-craft delete-key [key_name] [Option<key_path>]
+  - git-craft will show you what keys you have now, then remove keys by key name you entered, it should be used without key path now, because I set a default key path      
+ 
+
+
+## About Filter
+  
+1. edit .git/config "../craft/key_files/sec.asc" is a default key, you can use another key.
+- [filter "crypt"]
+	      smudge = ../craft/target/release/git-craft decrypt ../craft/key_files/sec.asc
+        clean = ../craft/target/release/git-craft encrypt ../craft/key_files/pub.asc
+2. edit .gitattributes
+- file_need_crypted filter=crypt -text
+- *.txt filter=crypt -text (it will use filter crypt at all txt file in this git dir)
+3. must be used arguments
+  1. Two commands below are used when you dont need crypt. 
+   - git -c filter.crypt.smudge=noop <option>
+   - git -c filter.crypt.clean=noop <option>
+
+## WARNING
+
+1. do not upload your key file to github, it must be saved at local file. I already add it in .gitignore.	
+ 
+
diff --git a/git-encrypt/craft/src/crypt.rs b/git-encrypt/craft/src/crypt.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c77f0b463815c5a5d6ea0acfd8cfac46abcb66d7
--- /dev/null
+++ b/git-encrypt/craft/src/crypt.rs
@@ -0,0 +1,145 @@
+use std::{io::Read, path::Path};
+
+use anyhow::{Context, Ok};
+use pgp_key::{generate_key_pair,encrypt_message, decrypt_message};
+
+use crate::pgp_key::{self, KeyPair, list_keys, delete_key};
+
+// Default key file path 
+const KEY_FILE_PATH:  &str= "../craft/key_files";
+
+// the trait and impl for KeyPair is a preparation for crate Tongsuo. 
+// a trait for key
+pub trait Key {
+    // type
+    type PublicKey;
+    type PrivateKey;
+
+    // function
+    // generate default key 
+    fn generate_key();
+    // generate key with primary id
+    fn generate_key_full(primary_id:&str, key_name:&str);
+    // encrypt with public key
+    fn encrypt(public_key_file_path: &str); 
+    // decrypt with private key
+    fn decrypt(private_key_file_path: &str);
+    // list keys
+    fn list_keys(key_path: &str);
+    // delete key
+    fn delete_key(key_name:&str, key_path: &str);
+}
+
+// OpenPGP Key
+impl Key for KeyPair {
+    type PublicKey = pgp::SignedPublicKey;
+    type PrivateKey = pgp::SignedSecretKey;
+
+    fn generate_key(){
+        let _ = generate_key();
+    }
+
+    fn generate_key_full(primary_id:&str, key_name:&str) {
+        let _ = generate_key_full(primary_id, key_name);
+    }
+
+    fn encrypt(public_key_file_path: &str){
+        let _ = encrypt_blob(public_key_file_path);
+    }
+
+    fn decrypt(private_key_file_path: &str){
+        let _ = decrypt_blob(private_key_file_path);
+    }
+
+    fn list_keys(key_path: &str){
+        let _ = list_keys(key_path);
+    }
+
+    fn delete_key(key_name:&str, key_path: &str){
+        let _ = delete_key(key_name, key_path);
+    }
+}
+// Generate default public key and secret key at /craft/key_files/ 
+pub fn generate_key() -> Result<(), anyhow::Error>{
+    println!("Creating key pair, this will take a few seconds...");
+    // Create default key file path if it is not exist.
+    std::fs::create_dir_all(KEY_FILE_PATH)?;
+            // deafult key pair  
+            let key_pair = generate_key_pair("User <craft@craft.com>").expect("Failed to generate key pair");
+            // Generate a public key
+            let pub_key = key_pair
+                .public_key
+                .to_armored_string(None)
+                .expect("Failed to convert public key to armored ASCII string");
+            // Write public key to pub.asc,it will replace the old pub.asc if there is already one
+            _=std::fs::write( "../craft/key_files/pub.asc",pub_key).context("Writing public key to file");
+            // Generate a secret key
+            let sec_key = key_pair
+                .secret_key
+                .to_armored_string(None)
+                .expect("Failed to convert secret key to armored ASCII string");
+            // Write secret key to sec.asc, it will replace the old sec.asc if there is alreay one
+            _=std::fs::write( "../craft/key_files/sec.asc",sec_key).context("Writing secret key to file");
+            Ok(())
+}
+
+// Generate full key with pubkey, seckey, primary id.
+// Arguments: primary_id, as &str, it should be written as "User <example@example.com>"; key_name, git-craft will keep ur key file as key_namepub.asc 
+pub fn generate_key_full(primary_id:&str, key_name:&str)-> Result<KeyPair, anyhow::Error> {
+    println!("Creating key pair, this will take a few seconds...");
+    // set a key file path
+    let key_file_path= Path::new("../craft/key_files");
+    // Create a key file path if default path is not exist.
+    std::fs::create_dir_all(key_file_path)?; 
+        // generate_key_pair to generate key with a given non-default key id
+        let key_pair=generate_key_pair(primary_id).expect("Failed to generate full key pair");
+        // Generate a public key with primary id
+        let pub_key = key_pair
+            .public_key
+            .to_armored_string(None)
+            .expect("Failed to convert public key to armored ASCII string");
+        // Add key_namepub.asc to key file path
+        let pub_key_file_path =key_file_path.join(format!("{}pub.asc", key_name));
+        // Write public key to file,it will replace the old same name's public key 
+        _=std::fs::write( pub_key_file_path,pub_key).context("Writing public key to file");
+        // Generate a secret key
+        let sec_key = key_pair
+            .secret_key
+            .to_armored_string(None)
+            .expect("Failed to convert secret key to armored ASCII string");
+        // Add key_namesec.asc to key file path
+        let sec_key_file_path = key_file_path.join(format!("{}sec.asc", key_name)); 
+        // Write secret key to file, it will replace the old same name's secret key.
+        _=std::fs::write( sec_key_file_path,sec_key).context("Writing secret key to file");    
+            
+    Ok(key_pair)
+}
+// A blob encrypt function,it can encrypt blob.data
+// Argument: public_key_file_path, public key's file path; I set a default path now.  
+pub fn encrypt_blob(public_key_file_path: &str)-> Result<(),anyhow::Error>{
+            // Read blob data from standard input stream
+            let mut blob_data = Vec::new();
+            std::io::stdin().read_to_end(&mut blob_data).unwrap();
+            // Get blob.data as msg to encrypt
+            let msg = std::str::from_utf8(&blob_data).expect("Invalid UTF-8 sequence");
+            // Encrypt the contents with the given public key 
+            let encrypted = encrypt_message(msg, public_key_file_path).expect("Failed to encrypt message");
+            // Print it, git will get encrypted data 
+            print!("{}", &encrypted);
+            Ok(())
+}
+
+// A blob decrypt function,it can decrypt blob.data encrypted by encrypted_blob()
+// Arguments: secret_key_file_path; I set a default one now. 
+pub fn decrypt_blob(secret_key_file_path:&str) -> Result<(),anyhow::Error>{
+            // Read blob.data from standard input stream
+            let mut blob_data = Vec::new();
+            std::io::stdin().read_to_end(&mut blob_data).unwrap();
+            // Set a encrypt_msg to get &str 
+            let encrypted_msg = std::str::from_utf8(&blob_data).expect("Invalid UTF-8 sequence");
+            // Decrypt contents with the given secret key
+            let decrypted_msg = decrypt_message(encrypted_msg, secret_key_file_path).expect("Failed to decrypt message");
+            // Print decrypted contents, then git will write decrypted contents to origin file
+            print!("{}", &decrypted_msg);
+            Ok(())
+}
diff --git a/git-encrypt/craft/src/encrypted_message.txt b/git-encrypt/craft/src/encrypted_message.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/git-encrypt/craft/src/encrypted_message.txt
@@ -0,0 +1 @@
+
diff --git a/git-encrypt/craft/src/lib.rs b/git-encrypt/craft/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..80905faef20c4ec393e4eb604b1d50e16486ab42
--- /dev/null
+++ b/git-encrypt/craft/src/lib.rs
@@ -0,0 +1,2 @@
+pub mod pgp_key;
+pub mod crypt;
\ No newline at end of file
diff --git a/git-encrypt/craft/src/main.rs b/git-encrypt/craft/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..96245a1a492fcf0827aa0ff9045e69b0e74e40ef
--- /dev/null
+++ b/git-encrypt/craft/src/main.rs
@@ -0,0 +1,196 @@
+
+use anyhow::{ Result, Ok};
+use git_craft::{pgp_key::{list_keys, delete_key}, crypt::{generate_key, encrypt_blob, decrypt_blob, generate_key_full}};
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(author = "Jiajun Li <frankanepc@gmail.com>", version = "0.1.0")]
+#[command(about = "Git crypt tool", long_about= "Usage: generate-key, generate-key-full [primary_id] [key_name], encrypt [public_key_path], decrypt [secret_key_path], list-keys , delete-key [key_name]")]
+struct CraftOptions {
+    //accept mutiple values, it needs 1 value at least
+    #[clap(num_args=1..,required=true)]
+    command: Vec<String>,
+}
+
+// Program main function
+// Arguments: accept command line arguments.
+fn main() -> Result<(), anyhow::Error> {
+
+    // Collect command line arguments into Args 
+    let args =CraftOptions::parse();
+    // Check if there is no argument
+    if args.command.is_empty() {
+        // If not, print the usage information and exit
+        println!("Available modes: generate-key, generate-key-full [primary_id] [key_name], encrypt [public_key_path], decrypt [secret_key_path], list-keys [key_path], delete-key [key_name] [key_path]");
+        return Ok(());
+    }
+
+    // Get the first argument as the mode of operation
+    let mode:&str =&args.command[0];
+    // Match the mode with different functions
+    match mode {
+        // Generate default key pair and save it to key_files
+        "generate-key" => {
+            // Generate key
+            let _ = generate_key();
+        }
+        // Generate key pair full to key_files and name it as your input
+        "generate-key-full" => {
+            // Generate a full key
+            let _ = generate_key_full(&args.command[1], &args.command[2]);
+        }
+        // Encrypt file contents with a public key
+        "encrypt" => {
+            // Encrypt blob.data
+            let _ = encrypt_blob(&args.command[1]);
+        }
+        // Decrypt file contents with a secret key
+        "decrypt" => {
+            // Decrypt blob.data
+            let _ =decrypt_blob(&args.command[1]);
+        }
+        "list-keys" => {
+            // Show key lists and their fingerprint, key id.
+            let _ = list_keys("../craft/key_files");
+        }
+        "delete-key" => {
+            // Delete key by key_name
+            let _ =delete_key(&args.command[1], "../craft/key_files");
+        }
+        // For any other mode, print an error message and exit
+        _ => {
+            println!("Invalid mode: {}", mode);
+            return Ok(());
+        }
+
+    }
+     Ok(())
+}
+
+// Add a tests module with the # [cfg (test)] attribute
+# [cfg (test)]
+mod tests {
+    
+    // Import the names from outer scope
+    use super::*;
+    
+    
+    // Define a test function for generate-key mode
+    # [test]
+    fn test_generate_key() {
+        // Generate key
+        let _ = generate_key();
+        // Check if the pub.asc and sec.asc files are created in the key_files directory
+        assert!(std::path::Path::new("../craft/key_files/pub.asc").exists());
+        assert!(std::path::Path::new("../craft/key_files/sec.asc").exists());
+    } 
+
+    // Define a test function for generate-key-full mode
+    #[test]
+    fn test_generate_key_full() {
+        // generate a full key
+        let _ = generate_key_full("User1 <goodman@goodman.com>", "goodman");
+        // check if the goodman.asc and sec.asc files are created in the default key file directory
+        assert!(std::path::Path::new("../craft/key_files/goodmanpub.asc").exists());
+        assert!(std::path::Path::new("../craft/key_files/goodmanpub.asc").exists());
+    } 
+  
+    // Define a test function for encrypt mode
+    # [test]
+    fn test_encrypt() {
+        // generate key to crypt
+        let _ = generate_key_full("User2 <sci@sci.com>", "sci");
+        // Read the file content and convert it to a vector of bytes
+        let vec = std::fs::read("../tests/data/objects/message.txt").expect("Failed to read file");
+        // Create a standard input stream from the vector of bytes
+        // Create and run a new process to execute the encrypt_blob function
+        let mut child = std::process::Command::new("cargo")
+            .arg("run")
+            .arg("encrypt")
+            .arg("../craft/key_files/scipub.asc")
+            .stdin(std::process::Stdio::piped()) // Pass the standard input stream as an argument
+            .stdout(std::process::Stdio::piped())
+            .spawn()
+            .expect("Failed to spawn child process");
+        
+        std::io::Write::write_all(&mut child.stdin.as_mut().unwrap(), &vec).expect("Failed to write to stdin");    
+        // Get the output of the child process
+        let output = child.wait_with_output().expect("Failed to read stdout");
+        // Check the output of the child process
+        assert_eq!(output.status.code(), Some(0)); // The status code should be 0
+        assert_eq!(output.stderr.len(), 0); // The standard error should be empty
+        // Check if the contents are encrypted by looking for the PGP header
+        assert!(output.stdout.starts_with("-----BEGIN PGP MESSAGE-----".as_bytes()));
+    }
+    
+    // Define a test function for decrypt mode
+    #[test]
+    fn test_decrypt() {
+        // Generate a key pair for testing
+        let _ = generate_key_full("User3 <basketball@basketball.com>", "ball");
+        // Define the original content as a string
+        let original_data = "This is a test message.";
+        
+        // Create a standard input stream from the string
+        // Create and run a new process to execute the encrypt function
+        let mut child_encrypt = std::process::Command::new("cargo")
+            .arg("run")
+            .arg("encrypt")
+            .arg("../craft/key_files/ballpub.asc")
+            .stdin(std::process::Stdio::piped()) // Pass the standard input stream as an argument
+            .stdout(std::process::Stdio::piped())
+            .spawn()
+            .expect("Failed to spawn child process");
+        
+        std::io::Write::write_all(&mut child_encrypt.stdin.as_mut().unwrap(), original_data.as_bytes()).expect("Failed to write to stdin");    
+        // Get the output of the child process
+        let output_encrypt = child_encrypt.wait_with_output().expect("Failed to read stdout");
+    
+        // Check the output of the child process
+        assert_eq!(output_encrypt.status.code(), Some(0)); // The status code should be 0
+        assert_eq!(output_encrypt.stderr.len(), 0); // The standard error should be empty
+    
+        // Create a standard input stream from the output of the encrypt function
+        // Create and run a new process to execute the decrypt function
+        let mut child_decrypt = std::process::Command::new("cargo")
+            .arg("run")
+            .arg("decrypt")
+            .arg("../craft/key_files/ballsec.asc")
+            .stdin(std::process::Stdio::piped()) // Pass the standard input stream as an argument
+            .stdout(std::process::Stdio::piped())
+            .spawn()
+            .expect("Failed to spawn child process");
+        
+        std::io::Write::write_all(&mut child_decrypt.stdin.as_mut().unwrap(), &output_encrypt.stdout).expect("Failed to write to stdin");    
+        // Get the output of the child process
+        let output_decrypt = child_decrypt.wait_with_output().expect("Failed to read stdout");
+    
+        // Check the output of the child process
+        assert_eq!(output_decrypt.status.code(), Some(0)); // The status code should be 0
+        assert_eq!(output_decrypt.stderr.len(), 0); // The standard error should be empty
+    
+        // Define the expected decrypted content as a string
+        let expected_data = "This is a test message."; 
+    
+        // Compare the output of the child process with the expected decrypted content
+        assert_eq!(output_decrypt.stdout, expected_data.as_bytes()); // The standard output should match the expected string
+    }
+    
+    // Define a test function for list-keys mode
+    # [test]
+    fn test_list_keys() {
+        let _ = generate_key();
+        let actual = list_keys("../craft/key_files").unwrap();
+        assert!(!actual.is_empty());
+        // Check if the output contains the expected key information
+    }
+
+    // Define a test function for delete-key mode
+    # [test]
+    fn test_delete_key() {
+        let _ = generate_key();
+        let _ = delete_key("", "../craft/key_files");
+        assert!(!std::path::Path::new("../craft/key_files/pub.asc").exists());
+        assert!(!std::path::Path::new("../craft/key_files/sec.asc").exists());
+    } 
+}
diff --git a/git-encrypt/craft/src/message.txt b/git-encrypt/craft/src/message.txt
new file mode 100644
index 0000000000000000000000000000000000000000..be4076ae9985093b9c654e9ec4d1b453c8018500
--- /dev/null
+++ b/git-encrypt/craft/src/message.txt
@@ -0,0 +1 @@
+This is a test message.
diff --git a/git-encrypt/craft/src/pgp_key.rs b/git-encrypt/craft/src/pgp_key.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a2d51904a9edc1dea22b9650f604cca3bbc9a989
--- /dev/null
+++ b/git-encrypt/craft/src/pgp_key.rs
@@ -0,0 +1,256 @@
+use anyhow::{Context, Result, Ok};
+
+use pgp::{composed, composed::signed_key::*, crypto::{self, sym::SymmetricKeyAlgorithm}, types::{SecretKeyTrait, KeyTrait}, Deserializable, Message};
+use rand::prelude::*;
+use smallvec::*;
+use std::{io::Cursor, path::Path};
+
+
+// Set some default file paths
+// Default public key file path
+#[allow(unused)]
+const PUBLIC_KEY_FILE: &str= "../craft/key_files/pub.asc";
+// Default secret key file path
+#[allow(unused)]
+const SECRET_KEY_FILE: &str= "../craft/key_files/sec.asc";
+// Encrypt function use this file to save encrypted message
+const MSG_FILE_NAME:  &str= "../craft/src/encrypted_message.txt";
+
+
+
+pub struct KeyPair {
+    pub secret_key: pgp::SignedSecretKey,
+    pub public_key: pgp::SignedPublicKey,
+}
+
+// Generate key pair function
+// Arguments: primary_user_id, it should input as "User <example@example.com>"
+// Return: KeyPair, it has a signed secret key and a signed public key
+pub fn generate_key_pair(primary_user_id: &str) -> Result<KeyPair, anyhow::Error> {
+
+    // Set key_params with primary user id, Rsa with 2048 bites, symmetric algorithms key prefer to use is AES with 256 bit
+    let mut key_params = composed::key::SecretKeyParamsBuilder::default();
+    key_params
+        .key_type(composed::KeyType::Rsa(2048))
+        .can_create_certificates(false)
+        .can_sign(true)
+        .primary_user_id(primary_user_id.into())
+        .preferred_symmetric_algorithms(smallvec![crypto::sym::SymmetricKeyAlgorithm::AES256]);
+
+    // build a new SecretKeyParams
+    let secret_key_params = key_params
+        .build()
+        .expect("Must be able to create secret key params");
+
+    // generate a secret key    
+    let secret_key = secret_key_params
+        .generate()
+        .expect("Failed to generate a plain key.");
+    
+    // new a password to sign the secret key 
+    let passwd_fn = String::new;
+    let signed_secret_key = secret_key
+        .sign(passwd_fn)
+        .expect("Secret Key must be able to sign its own metadata");
+    
+    // generate a public key by the signed secret key 
+    let public_key = signed_secret_key.public_key();
+    // sign public key 
+    let signed_public_key = public_key
+        .sign(&signed_secret_key, passwd_fn)
+        .expect("Public key must be able to sign its own metadata");
+
+    let key_pair = KeyPair {
+        secret_key: signed_secret_key,
+        public_key: signed_public_key,
+    };
+
+    Ok(key_pair)
+}
+
+// Encrypt function
+// Arguments: msg, contents need to encrypt; pubkey_str, public key as &str
+// Return: encrypted contents
+pub fn encrypt(msg: &str, pubkey_str: &str) -> Result<String, anyhow::Error> {
+    let (pubkey, _) = SignedPublicKey::from_string(pubkey_str)?;
+    // Requires a file name as the first arg, in this case I pass "none", as it's not used
+    let msg = composed::message::Message::new_literal("none", msg);
+    // Encrypt
+    let mut rng = StdRng::from_entropy();
+
+    let new_msg = msg.encrypt_to_keys(
+        &mut rng,
+        crypto::sym::SymmetricKeyAlgorithm::AES128,
+        &[&pubkey],
+    )?;
+    Ok(new_msg.to_armored_string(None)?)
+}
+
+// Decrypt encrypted contents
+// Arguments: armored, encrypted contents; seckey, secret key
+pub fn decrypt(armored: &str, seckey: &SignedSecretKey) -> Result<String, anyhow::Error> {
+    // Get encrypted contents
+    let buf = Cursor::new(armored);
+    let (msg, _) = composed::message::Message::from_armor_single(buf)
+        .context("Failed to convert &str to armored message")?;
+    // Set a decryptor
+    let (decryptor, _) = msg
+        .decrypt(|| String::from(""), &[seckey])
+        .context("Decrypting the message")?;
+    // Use decryptor to decrypt encrypted contents
+    for msg in decryptor {
+        let bytes = msg?.get_content()?.unwrap();
+        let clear_text = String::from_utf8(bytes)?;
+        if String::len(&clear_text) > 0 {
+            return Ok(clear_text);
+        }
+    }
+
+    Err(anyhow::Error::msg("Failed to find message"))
+}
+
+// Encrypt message from file, and write it to a MGS_FILE waiting for decrypt
+// Arguments: message, read from file; public key file path
+#[allow(unused)]
+pub fn encrypt_message(msg: &str, pubkey_file: &str) -> Result<String> {
+    let pubkey = std::fs::read_to_string(pubkey_file)
+        .context("Trying to load public key for Person Two from file")?;
+    let (pubkey, _) = SignedPublicKey::from_string(pubkey.as_str())?;
+
+    // Requires a file name as the first arg, in this case I pass "none", as it's not used typically, it's just meta data
+    let msg = pgp::Message::new_literal("none", msg);
+    // convert data from OpenPGP Message to string
+    let armored = generate_armored_string(msg, pubkey)?;
+    // write it to file
+    std::fs::write(MSG_FILE_NAME, &armored).context("Writing encrypted message to file")?;
+
+    Ok(armored)
+}
+
+// Convert data from OpenPGP Message to String
+// Arguments: msg, OpenPGP Message; pk, a signed public key
+// Return: string
+#[allow(unused)]
+pub fn generate_armored_string(msg: Message, pk: SignedPublicKey) -> Result<String> {
+    let mut rng = StdRng::from_entropy();
+    // encrypt the message 
+    let new_msg = msg.encrypt_to_keys(&mut rng, SymmetricKeyAlgorithm::AES128, &[&pk])?;
+    // return encrypted message as string 
+    Ok(new_msg.to_armored_string(None)?)
+}
+
+// Decrypt message from file
+// Arguments: armored, encrypted message;v seckey_file, secret key file path
+#[allow(unused)]
+pub fn decrypt_message(armored: &str, seckey_file: &str) -> Result<String,anyhow::Error> {
+    // read secret key from file path
+    let seckey = std::fs::read_to_string(seckey_file)?;
+    let (seckey, _) = SignedSecretKey::from_string(seckey.as_str())?;
+    // get encrypted message
+    let buf = Cursor::new(armored);
+    let (msg, _) = Message::from_armor_single(buf)?;
+    // return a decryptor, it can decrypt message with a given key
+    let (decryptor, _) = msg
+        .decrypt(|| String::from(""), &[&seckey])
+        .context("Decrypting the message")?;
+    // decrypt message
+    for msg in decryptor {
+        let bytes = msg?.get_content()?.unwrap();
+        let clear = String::from_utf8(bytes)?;
+        if String::len(&clear) > 0 {
+            return Ok(clear);
+        }
+    }
+
+    Err(anyhow::Error::msg("Failed to find message"))
+}
+
+// List keys and show their fingerprint, key id
+// Argument: key_path, key file path, I use a default file path in main.rs 
+// Return: public key and its name, secret key and its name
+#[allow(unused)]
+pub fn list_keys(key_path: &str)->Result<String>{
+    // Create a vector to store and output strings 
+    let mut output =Vec::new();
+    // Get an itreator over the key files in key file directory
+    let files = std::fs::read_dir(key_path).context("Trying to read key file directory")?;
+    for file in files{
+        // Get file path
+        let file_path = file.context("Trying to get the key file path")?.path();
+        // Get file name
+        let file_name = file_path.file_name().context("Trying to get the key file name")?.to_string_lossy();
+        // If the file name ends with .asc, get a key file
+        if file_name.ends_with(".asc") {
+            // Read the key file content as a string 
+            let key = std::fs::read_to_string(&file_path).context(format!("Trying to load key from {}", file_name))?;
+            // Check this key is a public key or a secret key
+            if key.contains("PUBLIC KEY"){
+                // Parse it as a public key
+                let (pubkey, _) = SignedPublicKey::from_string(key.as_str())?;
+                // Get the fingerprint bytes of the pubkey
+                let fingerprint = pubkey.fingerprint();
+                // Get the key id of the pubkey
+                let  key_id= pubkey.key_id();
+                // Print the fingerprint and key id of public key
+                println!("The {} public key's fingerprint is: {:?}", file_name, fingerprint);
+                println!("The {} public key's key_id is: {:?}", file_name, key_id);
+                // Format public key information as a string and push it to output vector
+                output.push(format!("Public key: {:?}\nFile name: {}\n", pubkey, file_name));
+            }
+            else if key.contains("PRIVATE KEY") {
+                // Parse it as a secret key
+                let (seckey,_) = SignedSecretKey::from_string(key.as_str())?;
+                // Get fingerprint of the seckey
+                let fingerprint =seckey.fingerprint();
+                // Get the key id of seckey
+                let key_id =seckey.key_id();
+                // Print the fingerprint and key id of secret key
+                println!("The {} secret key's fingerprint is: {:?}", file_name, fingerprint);
+                println!("The {} secret key's key id is: {:?}", file_name, key_id);
+                // format secret key information  as a string and push it to output vector
+                output.push(format!("Secret key: {:?}\nFile name: {}\n", seckey, file_name))
+            }
+            else {
+                // The file is not a vaild key file, skip it continue
+            }
+        }
+        else {
+            // The file is not a .asc file, skip it continue
+        } 
+
+    }
+    // Return the output as Ok result
+    Ok(output.join("\n"))
+}
+
+// Delete key function, it list keys first, then delete keys you input, 
+// Considering the public key and secret key should be used  together, it will be deleted together 
+// Arguments: key_path, default one is "/mega/craft/key_files"; key_name, key's name you want delete
+#[allow(unused)]
+pub fn delete_key(key_name: &str, key_path: &str)-> Result<(),anyhow::Error>{
+   // ############################################WARNING############################################# 
+   // git-craft v0.1.0 use crate pgp, and it will change crypt crate to crate Tongsuo at next version,
+   // However, I dont know about Tongsuo at all, so I just set default OpenPGP key as files,
+   // file path: "/mega/craft/key_files/pub.asc" "/mega/craft/key_files/sec.asc"
+   // If they are not exist, u can run basic generate-key to generate them, 
+   // or u can use generate-key-full to generate at other key file.
+   // ##############################################OVER##############################################  
+    
+    // list keys from default key path
+    list_keys(key_path);
+    // get default key file path
+    let key_file_path = Path::new(key_path);
+    // get public key file 
+    let pubkey_file = key_file_path.join(format!("{}pub.asc", key_name));
+    // delete public key file
+    std::fs::remove_file(pubkey_file).expect("Unable to remove public key file");
+    // print Public key XXX deleted successfully message
+    println!("Public key {} deleted successfully", key_name);
+    // get secret key file
+    let seckey_file = key_file_path.join(format!("{}sec.asc", key_name));
+    // delete secret key file
+    std::fs::remove_file(seckey_file).expect("Unable to remove secret key file");
+    // print Secret key XXX deleted successfully message
+    println!("Secret key {} deleted successfully", key_name);
+    Ok(())
+}