diff --git a/ApplicationCompartmentalization.c b/ApplicationCompartmentalization.c
new file mode 100644
index 0000000..857134c
--- /dev/null
+++ b/ApplicationCompartmentalization.c
@@ -0,0 +1,45 @@
+#include<cheri.h>
+#include<stdio.h>
+
+void componentA(){
+
+char buffer[128];
+
+//Assume cap_A is a capability  for component A's memory
+
+_capability char* buffer_cap = cheri_setbounds(buffer, sizeof(buffer));
+
+gets(buffer_cap); //protected by componentA's capability
+
+printf("componentA : You entered : %s\n", buffer);
+
+}
+
+void componentB (){
+
+int secret_data =42;
+
+//Assume cap_B is a capability for component B's memory
+
+// componentB has no access to componentA's memory 
+
+
+
+_capability int* secret_data_cap = cheri_setbounds(&secret_data, sizeof(secret_data));
+
+printf("componentB secret data is %d\n", *secret_data_cap);
+
+}
+
+int main() {
+
+// component A and component B are isolated with separate capabilities 
+
+componentA();
+componentB();
+
+return 0;
+
+} 
+
+
diff --git a/CHERIIn-Address-Space-Protection.c b/CHERIIn-Address-Space-Protection.c
new file mode 100644
index 0000000..b4e6bd7
--- /dev/null
+++ b/CHERIIn-Address-Space-Protection.c
@@ -0,0 +1,41 @@
+#include<cheri.h>
+
+struct capData {
+
+char data[100];
+
+};
+
+void component1(){
+
+struct capData* sharedData =(struct capData*)cheri_malloc(sizeof(struct capData));
+
+strcpy(sharedData->data, "Data from component1");
+
+//.. some code to pass sharedData to component2
+
+}
+
+//component2
+
+void component2(struct capData* sharedData) {
+
+printf("component2 read: %s\n",sharedData ->data);
+
+}
+
+int main() {
+
+
+struct capData* sharedData = NULL;
+
+component1(&sharedData);
+component2(sharedData);//ensures that capability restricts access
+
+cheri_free(sharedData);
+
+return 0;
+
+}
+
+
diff --git a/CHERIProvenanceOfPointer.c b/CHERIProvenanceOfPointer.c
new file mode 100644
index 0000000..ee30f60
--- /dev/null
+++ b/CHERIProvenanceOfPointer.c
@@ -0,0 +1,22 @@
+#include<cheri.h>
+#include<stdio.h>
+
+int main(){
+
+int myArray[10];
+
+int *ptr = &myArray[0]; // storing the pointer as a capability
+
+//perform a capability safe operation  - accessing a valid element 
+
+int myValue = *ptr; 
+
+// access within bounds
+
+int *new_ptr = ptr + 5; 
+
+printf("valid value : %d\n", myValue); 
+
+return 0;
+
+}
diff --git a/CHERISecureEncapsulation.c b/CHERISecureEncapsulation.c
new file mode 100644
index 0000000..c5fc6cf
--- /dev/null
+++ b/CHERISecureEncapsulation.c
@@ -0,0 +1,52 @@
+#include<cheri.h>
+#include<stdio.h>
+#include<string.h>
+
+struct Student{
+
+char name[100]; 
+
+int age;
+
+};
+
+//component1
+
+void component1(void* studentCapability){
+
+struct Student* student = cheri_setbounds(studentCapability,sizeof(struct Student));
+
+strcpy(student->name,"Alice");
+
+student->age=20;
+
+}
+
+//component2
+
+void component2(void* studentCapability){
+
+struct Student* student = cheri_setbounds(studentCapability,sizeof(struct Student));
+
+printf("componet2 reads: Name: %s, Age: %d\n", student->name, student->age);
+
+}
+
+int main (){
+
+//memory allocation for the student data 
+
+struct Student sharedStudent;
+
+void* studentCapability = cheri_setbounds(&sharedStudent,sizeof(struct Student));
+
+//components use capability to access the shared student data
+
+component1(studentCapability);
+component2(studentCapability);
+
+return 0;
+
+}
+  
+
diff --git a/CHERIcapabilitySweepingRevocation.c b/CHERIcapabilitySweepingRevocation.c
new file mode 100644
index 0000000..8592e96
--- /dev/null
+++ b/CHERIcapabilitySweepingRevocation.c
@@ -0,0 +1,47 @@
+#include<cheri.h>
+#include<stdio.h>
+int main() {
+
+//create a capability to a memory region 
+
+int data[10] = {0};
+
+cheri_object data_cap;
+
+data_cap = cheri_build_data_cap(data, sizeof(data), CHERI_PERM_LOAD|CHERI_PERM_STORE);
+
+//read and write access capability
+
+int* cap_ptr = cheri_cast(int*, data_cap);
+
+//read and write data 
+
+cap_ptr[0] = 42; 
+
+int value = cap_ptr[0];
+
+printf("initial value: %d\n", value);
+
+//let's simulate a security breach or a vulnerability detection 
+
+//decide to revoke or write access to the memory region 
+
+cheri_set_perms(&data_cap,CHERI_PERM_LOAD);//revoke write permissions
+
+//attempting to write after revoking triggers an exception 
+
+//uncommenting this line would trigger a capability violation exception 
+
+//cap_ptr[1]=99;
+
+//however,read access remains allowed 
+
+int read_value = cap_ptr[1];
+
+printf("read only value: %d\n", read_value);
+
+return 0; 
+
+
+}
+
diff --git a/ExploitingBufferOverflow.c b/ExploitingBufferOverflow.c
new file mode 100644
index 0000000..0a0734b
--- /dev/null
+++ b/ExploitingBufferOverflow.c
@@ -0,0 +1,38 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+int foo(char *str)
+
+{
+
+char buffer[100];
+
+/* The following statement has a buffer overflow problem */
+
+strcpy(buffer, str);
+
+return 1;
+
+
+}
+
+
+int main(int argc, char **argv)
+
+{
+
+char str[300];
+
+FILE *riskfile;
+
+riskfile = fopen("riskfile", "r");
+
+fread(str, sizeof(char), 300, riskfile);
+
+foo(str);
+
+printf("returned \n");
+
+return 1;
+}
diff --git a/LackofSecureEncapsulationIssue.c b/LackofSecureEncapsulationIssue.c
new file mode 100644
index 0000000..97ab6f5
--- /dev/null
+++ b/LackofSecureEncapsulationIssue.c
@@ -0,0 +1,51 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+struct Student {
+
+char name[100];
+
+int age;
+
+};
+
+struct Student* create_student(char name*, int age);
+
+struct Student* student = (struct Student*)malloc(sizeof(struct Student));
+
+if(student){
+
+strcpy(student->name, name);
+
+student->age = age; 
+
+}
+
+return student; 
+
+}
+
+int main() {
+
+struct Student* student1 = create_student("Alice", 20);
+
+struct Student* student2 = create_student("Bob", 22);
+
+//unintentional access to students data (no encapsulation)
+
+printf("student1: %s,%d\n", student2->name, student2->age);
+
+free(student1);
+free(student2);
+
+return 0;
+
+}
+
+
+
+
+
+
+
+
diff --git a/LacksSingleInAddressSpaceProtection.c b/LacksSingleInAddressSpaceProtection.c
new file mode 100644
index 0000000..20a97aa
--- /dev/null
+++ b/LacksSingleInAddressSpaceProtection.c
@@ -0,0 +1,30 @@
+#include<stdio.h>
+#include<string.h>
+
+char sharedData[100];
+
+//component1
+void component1(){
+
+strcpy(sharedData, "Data from component1");
+
+}
+
+//component2
+void component2(){
+
+printf("component2 reads: %s\n", sharedData);
+
+}
+
+int main(){
+
+component1();
+
+component2();
+
+return 0;
+
+}
+
+
diff --git a/StackMachineBufferOverflowExample1.rst b/StackMachineBufferOverflowExample1.rst
new file mode 100644
index 0000000..648f488
--- /dev/null
+++ b/StackMachineBufferOverflowExample1.rst
@@ -0,0 +1,107 @@
+==========================
+"Buffer Overflow" Example
+==========================
+
+Stack machine
+-------------
+For a typical C program, its memory is divided into different segments and stack is one of the segments. 
+Stack: The stack is used for storing local variables defined inside functions, data related to function calls including:
+for example, return address, etc... 
+
+The use of stack memory example
+-------------------------------
+
+.. code-block:: C
+
+    /**
+    * Stack and function call 
+    */
+     int x = 50;
+     int main()
+    {
+     int a = 5;   //stored on stack 
+     int b = 10;  //stored on stack  
+     static int y; 
+     // allocation of memory on heap
+     int * myPtr = (int *) malloc(2*sizeof(int));
+     // values 20 and 25 are stored on heap
+     myPtr[0]=20;    //stored on heap
+     myPtr[1]=25;    //stored on heap
+
+     free(myPtr);
+     return(1);
+    }
+In the above program, the variables a and b inside the program are local variables and they are stored on the program stack.
+Notice that the variable myPtr is also a local variable, it is also stored on the stack. However, myPtr as a pointer,
+pointing to a block of memory and dynamically allocated using malloc();the values 20, and 25 assigned to myPtr[0],
+and myPtr[1], are stored on the heap. 
+
+The understanding of how data is arranged inside a program memory helps to understand how buffer overflow attack and
+Vulnerability works.
+
+Since buffer overflow can happen on both stack and heap, the ways to exploit them are somehow different and in the program
+example below we focus on stack buffer overflow and it is important to understant what information that could be stored on 
+the program memory stack, as shown in the above program example. 
+
+Stack is used for storing data in function calls. Normally, when a program runs it executes a series of function calls.
+Whenever a function is called, a space is created and allocated on the stack for the execution of that function. 
+
+
+.. code-block:: function 
+    /**
+    * function code 
+    */
+
+      void myFunc(float x, float y)
+    {
+       float a, float b;
+       a = x*y;
+       b = x+y; 
+    }
+
+When myFunc is called, a block of memory space will be allocated on top of the program stack and the values of the arguments,
+will also be pushed into the stack. 
+When myFunc finishes, its return instructions, will be placed into the top of the program stack, and this is 
+a return address. 
+
+Stack Buffer Overflow Vulnerability and attack
+-----------------------------------------------
+When a program needs to copy a memory, data from one place need to be copied to another place. 
+Before this happen, a program needs to allocate sufficient memory space to be able to copy for the destination buffer.
+When more that are copied to the destination buffer than the amoout of allocated space, this creates a buffer overflow. 
+
+.. code-block:: C 
+
+   /**
+   *  buffer overflow program 
+   */
+      
+    #include <string.h>
+    void foo(char *str)
+    {
+
+     char buffer[12];
+
+     /* The following statement will result in a buffer overflow */
+
+     strcpy(buffer, str);
+
+    }
+     int main()
+
+    {
+
+     char *str = "This is definitely longer than 12";
+     foo(str);
+     return 1;
+
+    }
+The program stack memory for the aboe code, the local array buffer [] in foo () function has 12 bytes of memory.
+The function foo() uses strcpy() to copy the string from str to the target buffer. 
+It is important to know that, normally this strcpy() function will not until it finds a number 0 in the above string. 
+Given that the provided string is longer that 12 bytes, strcpy() will need to overwrite some portion of the program stack,
+and this causes a buffer overflow. 
+Some programming languages such as Java, can detect straightaway this simple mistake, when buffer is over-run. 
+But pointer languages, such as C or C++, can find hard to detect it. 
+As consequence, buffer overflow can cause a program to crash due to the corruption of the data beyond the buffer,
+but could also enable adversaries or attackers to gain control of that program. 
diff --git a/bufferOverflow.c b/bufferOverflow.c
new file mode 100644
index 0000000..88b81ae
--- /dev/null
+++ b/bufferOverflow.c
@@ -0,0 +1,27 @@
+#include <string.h>
+
+void foo(char *str)
+
+{
+
+char buffer[12];
+
+/* The following statement will result in a buffer overflow */
+
+strcpy(buffer, str);
+
+}
+
+int main()
+
+{
+
+char *str = "This is definitely longer than 12";
+
+
+foo(str);
+
+
+return 1;
+
+}
diff --git a/pointerProvenanceIssue.c b/pointerProvenanceIssue.c
new file mode 100644
index 0000000..94d9761
--- /dev/null
+++ b/pointerProvenanceIssue.c
@@ -0,0 +1,27 @@
+
+#include<stdint.h>
+#include<stdio.h>
+
+int main () {
+
+int myArray[10];
+
+uintptr_t ptr =  (uintptr_t)&myArray[0]; //storing the address as uintptr_t
+
+//performing an invalid operation - accessing a non existent element 
+
+uintptr_r myPtr = ptr + sizeof(int)* 20; 
+
+//trying to accessing the memory using an invalid pointer 
+
+int myValue = *(int*)myPtr   // no memory safety checks 
+
+printf("invalid value : %d\n ",myValue);
+
+
+return 0;
+
+}  
+ 
+
+