@GetMapping("/create")
public String create(QuestionForm questionForm) {
    return "question_form";
}

// 내부적으로는 아래와 같은 코드와 동일하게 작동함:
model.addAttribute("questionForm", new QuestionForm());

2. 수동 바인딩 방식 (Model 이용)

@GetMapping("/create")
public String create(Model model) {
    model.addAttribute("questionForm", new QuestionForm());
    return "question_form";
}

3. 명시적 @ModelAttribute 방식

@GetMapping("/create")
public String create(@ModelAttribute("questionForm") QuestionForm form) {
    return "question_form";
}

= 같은 곳에 유효성 검사를 추가하면 코드 중복이 발생한다.

• 도메인 지식 같은 경우 -> Domain(Entity)에 유효성 검사를 해야한다.

• 도메인 지식과 무관하게 데이터 그 자체가 유효한가에 대한 검사 -> DTO에서 해야한다.

  @Getter
  @Setter
  @Entity
  public class Food {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Integer id;// 고유 번호
  
   @Column(length = 50)
   @Size(max = 50)
   private String foodname; // 식품명
  
   @Column(length = 30)
   @Size(max = 30)
   private String kind; // 종류
  
   private List<String> createDate;//날짜
  
   private String storageArea; // 구역
  
  
  

private LocalDateTime modifyDate; // 최종 수정 날짜

@ManyToOne// 작성자와의 관계 설정
private SiteUser siteuser;

private String imagePath; //이미지 경로

}

```

• @Size를 추가하여 유효성 검사를 추가했다.

  @Getter
  @Setter
  @Entity
  public class FoodFormDto {
   @NotEmpty(message="식품 이름은 필수 항목입니다.")
   @NotNull
   private String foodName;
  
   @NotEmpty(message="식품 종류 선택은 필수 항목입니다.")
   @NotNull
   private String kind;
  
   @NotEmpty(message="유통기한은 필수 항목입니다.")
   @NotNull
   private List<String> createDate;//날짜
  
   @NotEmpty(message="영역은 필수 항목입니다.")
   @NotNull
   private String storageArea;
  

• 입력 폼에 대한 @NotEmpty @NotNull을 이용하여 유효성 검사를 추가했다.

- Data Transfer Object란 의미로 폼에서 전달받은 데이터를 객체로 변환하는것.

• dto로 받은 데이터는 최종적으로 데이터베이스로 저장.

1. 데이터를 form을 통해 Post 요청으로 데이터를 요청.

• 폼 데이터를 전송 받아 DTO 객체에 담아야한다. -> post 요청
• 폼 데이터를 DTO에 담기 -> 컨트롤러에 매개 변수로 담는다.
• 폼과 DTO 필드를 연결하자 -> 타임리프를 통해 mapping
• DTO를 데이터베이스에 저장하자 -> DTO를 엔티티로 변환하자.
• repository로 엔티티를 db에 저장하자 -> repository.save(Entity);

// foodcreate_form.html

<form class="container" action="/api/food" method="post">
 <div class="mb-3">
            <label for="foodName" class="form-label">식품명</label>
            <input type="text" name="foodName" id="foodName" class="form-control" placeholder="ex) 버터 치킨 카레">
</div>
<div class="mb-3">
            <label for="createDate" class="form-label">유통 기한</label>
            <input type="text" name="createDate" id="createDate" class="form-control" placeholder="ex) 25/01/01">
</div>
</form>

  DTO

public class FoodFormDto{

private String foodName;
private String createDate;

// 전송 받은 이름과 날짜를 저장하는 생성자 추가
public foodFormDto(String foodName,String createDate){ 
this.foodName = foodName;
this.createDate = createDate;
}
// dto를 entity로 변환
public Food toEntity(){
return new food(null,foodName,createDate);
}

@Controller
public class foodcontroller(FoodFormDto foodFormDto){
@Gemapping("/api/food")
public String create(FoodFormDto foodFormDto){
Food food = foodFormDto.toEntity();
this.foodrepository.save(food);

}

@Entity
public class Food{
@Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;// 고유 번호

    @Column(length = 50)
    private String foodname; // 식품명

    private String createDate; // 제조일자
}

public Food(String foodname,String createDate){
this.foodname = foodname;
this.createDate = createDate;
}

1. 개요

본 문서는 Spring Boot 3 기반의 유통기한 기록, 문의사항, 보충 리스트 관리 웹/모바일 반응형 웹사이트 구축에 대한 설계 과정, MVC 패턴 적용, 요구사항 정의한다.

2. 시스템 설계

2.1 아키텍처

• 프론트엔드: 반응형 디자인 (BootStrap)
• 백엔드: Spring Boot 3 (RESTful API), Spring Data JPA (데이터베이스 연동), Thymeleaf (서버 사이드 렌더링)
• 데이터베이스: MySQL 또는 H2 (개발 환경)
• 웹 스토리지: HTML5 Web Storage (localStorage 또는 sessionStorage)

  2.2 MVC 패턴

• Model: 데이터베이스 엔티티 (Entity) 및 데이터 처리 로직 (Service)
• View: Thymeleaf 템플릿 (웹 페이지)
• Controller: RESTful API 엔드포인트, 웹 페이지 요청 처리

  2.3 주요 기능

• 유통기한 기록: 제품별 유통기한 등록, 수정, 삭제, 조회
• 문의사항 관리: 사용자 문의 등록, 답변, 조회
• 보충 리스트 관리: 유통기한 기반 보충 필요 제품 목록 생성, 보충 수량 기록, 웹 스토리지 연동

3. 요구사항 정의

3.1 기능 요구사항

<1> 식품 리스트 관리

• 제품 정보 (제품명, 유통기한, 종류) 등록/수정/삭제
• 제품 정보 검색 기능
• 페이징 기능
• 유통기한 임박/만료 제품 목록 조회 < 변경 UI >
• 카드로 제품들을 정리

<2> 보충 리스트

• 보충 리스트 관리
• 현장에서 보충 수량 입력으로 웹 스토리지 저장
• 보충 완료 목록 조회
• 보충 이력 조회
• 리스트 검색 기능

  <3> 문의 사항

• 문의사항 관리
• 사용자 문의 등록 (제품, 문의 내용)
• 관리자 답변 등록
• 문의 목록 조회 (사용자, 관리자)
• 문의 검색 기능 (제품, 내용)

3.2 비기능 요구사항

• 반응형 디자인: 다양한 기기 (PC, 태블릿, 모바일) 지원
• 성능: 빠른 응답 속도, 대용량 데이터 처리
• 보안: 사용자 인증/인가, 데이터 암호화
• 사용성: 직관적인 UI/UX, 쉬운 사용법
• 확장성: 새로운 기능 추가 용이
• 유지보수성: 코드 가독성, 유지보수 용이

4. 개발 과정

• 요구사항 분석 및 설계: 기능 요구사항, 비기능 요구사항 정의, 시스템 아키텍처 설계
• 데이터베이스 설계: ERD 작성, 테이블 설계
• 백엔드 개발: Spring Boot 3, Spring Data JPA, RESTful API 개발
• 프론트엔드 개발: BootStrap -> 반응형 디자인 적용
• 웹 스토리지 연동: 보충 리스트 데이터 웹 스토리지 저장/관리
• 테스트: 단위 테스트, 통합 테스트, 시스템 테스트
• 배포: 서버 배포, 운영 환경 설정
• 유지보수: 버그 수정, 기능 개선, 성능 최적화

5. 기술 스택

• Spring Boot 3: 백엔드 프레임워크
• Data JPA: 데이터베이스 연동
• Thymeleaf: 서버 사이드 렌더링
• Bootstrap: 반응형 디자인 프레임워크
• MySQL/H2: 데이터베이스
• HTML5 Web Storage: 웹 스토리지

6. 문서화

• 요구사항 정의서
• 시스템 설계서
• 데이터베이스 설계서
• API 명세서
• 테스트 계획서
• 사용자 매뉴얼

스프링 컨테이너 생성

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

• ApplicationContext -> 스프링 컨테이너이자 인터페이스
• 스프링 컨테이너 xml기반,Annotation을 기반으로 자바 설정 클래스로 만들 수 있다.

스프링 컨테이너의 생성 과정

1. 스프링 컨테이너 생성

• 스프링 컨테이너에 (key : 빈이름(메소드명),value : 빈 객체(메소드 반환명 impl)
• 구성 정보 = AppConfig.class
• 이러한 구성 정보를 지정하고 활용한다.

2. 스프링 빈 등록

• 빈 이름은 메서드 이름 사용.
• 빈 이름 직접 부여 가능

  @Test
  @Bean(name:'sprintHi')
  public ~~

3.스프링 빈 의존관계 설정(DI)

• 메소드의 반환값을 의존하는 메서드로 입력.

  @Bean
  public MemberService memberService(){
  return new MemberServiceImpl(memberRepository());
  }
  

@Bean public MemberRepository memberRepository(){ return new MemberMeberRepository(); }

### 컨테이너에 등록된 모든 빈 조회
-> 스프링 컨테이너에 등록한 빈들이 잘 등록 되었는가?
1. 내부 bean + 등록한 bean 출력
2. 내부 bean만 출력

### 스프링 빈 조회 방법
1. ac.getBean(빈이름,타입)
2. ac.getBean(타입)
3. 예외발생시(NoSuchBeanDefinitionException) 예외를 사용하여 조회

### 스프링 빈 조회 - 동일한 타입이 둘 이상일때
- 같은 타입의 스프링 빈일때 오류 발생 -> 빈이름 저장하여 조회
- ac.getBeansOfType() -> 모든 빈 조회 가능

정의: 분할정복 방식을 사용해 데이터를 분할하고 분할한 집합을 합치는 알고리즘이다.

• 시간 복잡도는 O(nlogn)

• 배열의 크기를 n이라 할때, 분할 할때 마다 배열의 크기가 n/2씩 감소. 이때 분할하는데 걸리는 시간은 O(log n)

• 정복(합병)할때 마다 두 배열을 비교하면서 작은 요소부터 차례로 결과 배열에 추가. 이 과정에서 최대 (n)개의 요소를 비교하게 되므로, 두 개의 배열을 합치는 데 걸리는 시간은 O(n)

• 대량의 데이터 정렬에 주로 사용.

public class sort {
    public static void merge(int A[], int low, int mid, int high) {
        //정렬할게요.
        int B[] = new int[high + 1];
        int h = low; //임시 배열 B의 low.
        int i = low; //배열 A의 low
        int j = mid + 1; // 배열 A의 mid +1
        int k;

        while (i <= mid && j <= high) {
            if (A[i] < A[j]) {
                B[h] = A[i]; //작은 놈이 임시 배열 low 지수에 저장.
                i++; // 왼쪽 배열 포인터 증가
            } else{
                B[h] = A[j];
                j++;// 오른쪽 배열 포인터 증가
            }
            h++; //임시배열도 저장할 포인터를 1만큼 증가.
        }

        // 비교할게 없다면?
        if (i > mid) { // 오른쪽 배열을 싹다 대입.
            for (k = j; k <= high; k++) {
                B[h] = A[k];
                h++;
            }
        }else { // 왼쪽 배열을 싹다 임시배열 B에 대입.
            for (k = i; k <= mid; k++) {
                B[h] = A[k];
                h++;
            }
        }

        /*while (i <= mid) {
            B[h] = A[i];
            i++;
            h++;
        }
        while (j <= high) {
            B[h] = A[j];
            j++;
            h++;
        }

         */

        for (k = low; k<=high; k++) {
            A[k] = B[k];
        }
    }

    public static void printArray(int A[]) {
        for (int i = 0; i < A.length; i++) {
            System.out.print(A[i] + " ");
        }
    }

    public static void mergeSort(int A[], int low, int high) { //합병할게요
        if (low < high) {
            int mid = (low+high) /2;
            mergeSort(A,low,mid);
            mergeSort(A,mid+1,high);
            merge(A,low,mid,high);
        }
    }

    public static void main(String[] args) {
        int A[] = {91, 82, 13, 85, 68, 70, 98, 24};
        System.out.println("정렬전");
        printArray(A);
        System.out.println("정렬후");
        mergeSort(A,0,A.length-1);
        printArray(A);
    }
}

정의 : 분할정복 알고리즘으로 부분적으로 나누어가면서 정렬하는 방법.

• 시간 복잡도 최악: O(n^2) 평균: O(n*logn)

• java에서 Arrays.sort()로 사용한다.

Quick Sort 실행 방식

1. 배열을 두 부분으로 나눈다. i) 배열 내 기준 요소보다 작으면 앞부분 배열에 위치, 크면 뒷부분 배열에 위치한다.

2. 각 분할된 부분을 재귀적으로 정렬한다.

package javastudy;

public class quickSort {
  public static void qs(int a[], int low, int high) {
    if (low < high) {
      int s = partition(a, low, high); // 기준 pivot
      qs(a, low, s - 1); // 왼쪽 배열
      qs(a, s + 1, high); // 오른쪽 배열
    }
  }

  public static int partition(int a[], int low, int high) {
    int pivot = a[low]; // 피벗을 배열의 첫 번째 요소로 설정
    int i = low + 1;
    int j = high;

    while (i <= j) {
      while (i <= high && a[i] <= pivot) {
        i++;
      }
      while (j >= low && a[j] > pivot) {
        j--;
      }
      if (i < j) { // i가 j보다 작을 때만 교환
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
      }
    }
    // 피벗을 올바른 위치에 배치
    a[low] = a[j];
    a[j] = pivot;

    return j; // 피벗의 최종 위치 반환
  }

  public static void printArray(int a[]) {
    for (int num : a) {
      System.out.print(num + " ");
    }
    System.out.println(); // 배열 출력 후 줄바꿈
  }

  public static void main(String[] args) {
    int a[] = {8, 5, 6, 2, 4};
    printArray(a);
    qs(a, 0, a.length - 1); // 배열의 크기를 사용하여 인덱스 설정
    printArray(a);
  }
}

정의 : 자신의 위치를 찾아 삽입하는 정렬 알고리즘.

• 정렬된 부분 (A[0]), 정렬 되지 않은 부분 (A[1] ... A[n-1])으로 구분하여 정렬.
• 시간복잡도 : O(n^2)

package javastudy;

public class insertSort {
  public static void is(int a[]) {
    int n = a.length;
    for (int i = 1; i < n; i++) {
      int insertionKey = a[i]; // 삽입할 현재 요소
      int j = i - 1;

      while (j >= 0 && a[j] > insertionKey) {
        a[j+1] = a[j]; // 한칸 뒤로
        j = j-1; // 왼쪽 index로 이동
      }
      a[j+1] = insertionKey; // 현재 요소 삽입
    }
  }

  public static void printArray(int a[]) {
    for (int num : a) {
      System.out.print(num+ " ");
    }
  }

  public static void main(String[] args) {
    int A[] = {8, 5, 6, 2, 4};
    System.out.println("정렬 전");
    printArray(A);
    System.out.println("정렬 후");
    is(A);
    printArray(A);
  }
}

정의 : 전체 배열에서 가장 작은 요소를 찾고, 그 요소를 첫번째 요소와 교환하는 정렬.

• 시간 복잡도 : O(n^2)

package javastudy;

public class selectionSort {
  public static void ss(int a[]) {
    int n = a.length;


    for (int i = 0; i < n - 1; i++) {
      int min = i;
      for (int j = i+1; j < n; j++) {
        if (a[min] > a[j]) {
          min = j;
        }
      }
        if (min != i) {
          int tmp = a[i];
          a[i] = a[min];
          a[min] = tmp;
        }

    }
  }

  public static void printArray(int a[]) {
    for (int num : a) {
      System.out.print(num+" ");
    }
  }

  public static void main(String[] args) {
    int A[] = {8, 5, 6, 2, 4};
    System.out.println("정렬 전");
    printArray(A);
    System.out.println("정렬 후");
    ss(A);
    printArray(A);

  }

}

정의 : 인접한 두 원소를 비교하여, 큰 수를 계속해서 뒤로 보내 정렬 하는 방식.

• 시간복잡도 O(n^2)
• 대규모 데이터에는 부적합 -> 퀵 정렬, 병합 정렬을 주 사용.

버블 정렬 작동 원리

1. 첫번째 항목부터 마지막 항목까지 순차적으로 이동하면서 인접한 항목을 비교한다.
2. 인접한 두 항목을 비교하면서 왼쪽항목(A[j]) 이 오른쪽 항목 보다(A[j+1]) 크면 위치를 바꾼다.
3. 위의 과정을 반복한다.

package javastudy;

public class bubbleSort {
  public static void bs(int a[]){
    int n = a.length; // 배열 길이.
    boolean swapped;
    int temp;

    for (int i = 0; i < n -1; i++){
      swapped = false; // 스왑 여부 초기화
      for (int j = 0; j < n-i-1; j++){
        if(a[j]>a[j+1]){
          temp = a[j];
          a[j] = a[j+1];
          a[j+1] = temp;
          swapped = true;
        }
      }
      if (!swapped){
        break;
      }
    }
  }

  public static void printArray(int a[]){
    for (int num : a){
      System.out.print(num+" ");
    }
  }

  public static void main(String[] args) {
    int a[] = {8,5,6,2,4};
    System.out.println("정렬전");
    printArray(a);
    System.out.println("정렬후");
    bs(a);
    printArray(a);
  }
}

• 비선형 자료구조
• 점 : 노드(Node),정점(Vertex)
• 선 : link,edge(간선)
• degree : 정점(vertex)에 부속된 간선(edge) 수

그래프 종류

• 무방향 그래프 : 두 정점을 연결하는데 간선에 방향이 없는 그래프
• 방향 그래프 : 두 정점을 연결하는데 간선에 방향이 있는 그래프
• 완전 그래프 : 모든 정점들이 연결되고, 최대 간선수를 가지는 그래프

• n개 정점에서 무뱡향 & 완전그래프 최대 간선 수 : n(n-1)/2

• n개 정점에서 뱡향 & 완전그래프 최대 간선 수 : n(n-1)

• 부분 그래프 : 일부 정점이나 간선을 제외하여 만든 그래프
• 가중 그래프 : 간선에 가중치를 할당한 그래프
• 유향 비순환 그래프 : 방향그래프에서 cycle이 없는 그래프
• 연결 그래프 : 떨어져있는 정점이 없는 그래프
• 단절 그래프 : 떨어져있는 정점이 있는 그래프

Spinning Tree

MST(Minimum Spinning Tree)

구현하는 방법

1. krusal's Algorithm

2. prim's Algorithm

• 완전 이진 트리 일종.
• 힙(Heap)은 삽입 및 삭제 연산에 있어서 뛰어난 성능
• 최대힙,최소힙 => 최대,최소를 찾을때 좋음

시간 복잡도

• 삽입: O(log n)
• 삭제(최대 또는 최소): O(log n)
• 접근(최대 또는 최소): O(1)

• 하나의 루트 노드를 갖는 계층형 자료구조
• degree: 노드의 차수 -> 한 노드가 가지는 서브 노드의 수.

Binary Tree ( 이진 트리 )

• 각 노드의 degree가 2이하인 tree로 왼쪽,오른쪽 서브트리로 구성.

1. 포화 이진 트리

• 모든 leaf노드들의 level이 동일하며, 내부노드들의 degree가 2

2. 완전 이진 트리

• 포화 이진트리의 leaf노드들이 오른쪽부터 삭제된 트리

Binary Search Tree (BST, 이진 탐색 트리)

• 이진트리 형태로 각 노드의 왼쪽 서브트리에는 부모 노드보다 작은 값이, 오른쪽 서브트리에는 부모 노드보다 큰 값이 위치하는 트리

• 흐름

1. 시작은 루트
2. 이진 탐색 트리가 null이면 실패.
3. root의 키값이 = x 이면, 탐색은 성공하며 종료
4. 키값 < x 이면, 왼쪽 서브트리에서 탐색. 키값 > x 이면 , 오른쪽 서브트리에서 탐색.

package javastudy;

import com.sun.source.tree.Tree;

// 트리 구조 노드 연결리스트.
class TreeNode {
  int value;
  TreeNode left;
  TreeNode right;

  public TreeNode(int value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}
public class tree {
  TreeNode root; //루트 노드 선언.

  public void insert(int value) {
    TreeNode newNode = new TreeNode(value);
    if (root == null) { //root가 없으면?
      root = newNode; //새로 생성된 node가 root
    }else{ //root가 있다면?
      TreeNode current = root;// current 변수는 root를 가리킴.

      //비교해야함.
      while (true) {
        if (value < current.value) {
          if (current.left == null) {//왼쪽 서브트리가 없다면
            current.left = newNode;//왼쪽에 서브트리노드를 생성
            return;
          }
          current = current.left; //왼쪽에 서브트리가 있으면 왼쪽 서브트리로 이동.
        } else if (value > current.value) {
          if (current.right == null) {
            current.right = newNode;
            return;
          }
          current = current.right; // 오른쪽 서브트리로 이동
        }
      }
    }
  }

  public void delete(int value) {
    root = deleteNode(root,value);
  }

  TreeNode deleteNode(TreeNode node, int value) {
    if (node == null) {
      return null;// 찾는 노드가 존재하지 않는다.
    }

    if (value < node.value) {
      node.left = deleteNode(node.left,value); //왼쪽 서브트리 삭제.
    } else if (value > node.value) {
      node.right = deleteNode(node.right,value);// 오른쪽 서브트리 삭제.
    }else{
      //삭제할 노드가 발견됨 -> 자식이 없는경우 총 3가지로 구분
      //1. 해당 노드의 자식이 없는경우
      if(node.left == null && node.right == null){
        return null; // 해당 노드를 삭제.
      }
      //2. 해당 노드의 자식이 한개인 경우.
      else if(node.left == null){
        return node.right; //오른쪽 자식노드로 대체.
      }else if(node.right == null){
        return node.left; //왼쪽 자식노드로 대체
      }else {
        //3.해당 노드의 자식이 두개인 경우.
        TreeNode successor = node.right; //오른쪽 서브트리에서 최소값을 찾았을때.
        while(successor.left != null){ //자식노드의 왼쪽이 비어있다면
          successor = successor.left;
        }
      }


    }
    return node;
  }
  // 특정 값 검색
  public boolean search(int value) {
    TreeNode current = root;

    while (current != null) {//노드가 있다..
      if (current.value == value) {
        return true; // 값이 존재하는 경우
      } else if (value < current.value) {
        current = current.left; // 왼쪽으로 이동
      } else {
        current = current.right; // 오른쪽으로 이동
      }
    }

    return false; // 값이 존재하지 않는 경우
  }

  //전위 순회
  public void preOrder(){
    preOrderTraversal(root);

  }
  private void preOrderTraversal(TreeNode node){
    if(node != null){
      System.out.print(node.value +" ");
      preOrderTraversal(node.left);
      preOrderTraversal(node.right);
    }
  }
  //중위 순회
  public void inOrder(){
    inOrderTraversal(root);
  }
  private void inOrderTraversal(TreeNode node){
    if(node != null){
      inOrderTraversal(node.left);
      System.out.print(node.value+" ");
      inOrderTraversal(node.right);
    }
  }
  public void postOrder(){
    postOrderTraversal(root);
  }
  //후위 순회
  private void postOrderTraversal(TreeNode node){
    if(node != null){
      postOrderTraversal(node.left);
      postOrderTraversal(node.right);
      System.out.print(node.value+" ");
    }
  }

  public static void main(String[] args) {
    tree t = new tree();

    t.insert(50);
    t.insert(30);
    t.insert(20);
    t.insert(40);
    t.insert(70);
    t.insert(60);
    t.insert(80);

    t.inOrder(); //20 30 40 50 60 70 80
    t.postOrder();//20 40 30 60 80 70 50  
    t.preOrder();//50 30 20 40 70 60 80 


  }

}

축구선수 성과 분석 시스템.

• Mysql
• 관계형 데이터베이스로 설계.

주요 테이블

• players: 선수 정보
• player_stats: 선수별 경기 통계(득점,슈팅,도움,드리블,패스,출전경기수)
• teams: 각 팀 정보
• teams_stats: 각 팀 스탯(승,무,패 등)

players 테이블

player_stats 테이블

teams 테이블

teams_stats 테이블

SSH 에이전트(SSH Agent)는 SSH 키의 비공개 키를 메모리에 저장하고 관리하는 프로그램. 이를 통해 사용자는 비밀번호 입력 없이 SSH 키를 사용하여 여러 SSH 연결을 쉽게 관리.

SSH Key vs SSH Agent

ssh-key는 SSH 프로토콜을 사용하여 인증을 수행하는 암호화 키.

• 비공개 키는 사용자만 알고 있어야함. 공개 키는 서버(진입하려는 서버 = authorized_keys)에 저장되어, 클라이언트가 인증을 요청할 때 서버가 클라이언트를 신뢰(known_hosts)하는지 확인.

SSH 에이전트는 SSH 클라이언트가 비공개 키를 메모리에 저장하고 관리. 사용자가 비밀번호를 입력하지 않고도 여러 SSH 연결하게 하는 것.

• 비공개 키를 메모리에 보관하고, SSH 연결 시 자동으로 인증을 수행. 사용자가 처음 한 번만 비밀번호를 입력하면, 이후에는 자동으로 인증을 처리.

매번 key 파일을 지정하는것이 귀찮음. -> agent로 처리.

open-ssh로 agent를 띄우기.

키 파일 추가/삭제

$ssh-add ~/.ssh/id_rsa
$ssh-add -d ~/.ssh/id_rsa

• 원격 호스트에 접속하기 위한 프로토콜
• port = 22 (변경 가능)

shell -> os기능을 user가 사용할 수 있게 하는 프로그램

• GUI
• CLI

Vmware -> kali-linux 서버를 putty를 이용하여 ssh로 진입해보기.

1. ssh server port 확인

$netstat -na | grep
또는 
$nmap localhost

2. ssh install

$sudo apt install ssh

3. ssh 서비스 시작

$ssh service ssh start

4. ssh 상태 확인

$systemctl status ssh

5. ip a 명령어를 통해 kali ip주소를 확인.

ip 주소는 eth0(이더넷) 192.168.8.129 인것을 확인.

putty에서 ssh로 진입

ssh로 진입성공.

SSH Key

ssh로 접속하는 방법은 여려가지가 있다.

1. ID와 Password로 접속하는 방법.

-> 보안상 문제, 타이핑의 존재 등..

2. SSH Key를 이용하는 방법

SSH 키는 두 개의 키 쌍으로 구성.

- 공개 키 (Public Key): 다른 사람과 공유할 수 있는 키로, 서버에 저장.

- 비공개 키 (Private Key): 개인적으로 보관해야 하는 키

$ssh-keygen -t rsa
## RSA 알고리즘을 이용한 키 만들기 ##

ssh key 파일 확인

$ls -la $HOME/.ssh/id_rsa*   

SSH Key를 이용하여 접근 허용 목록에 등록해보기.

$cd ~/.ssh
$cat id_rsa.pub > authorized_keys

-> 허용 목록에 진입하려는 서버의 key를 등록하는것.

$ssh localhost

접근 목록에 공개키를 저장했기에 비밀번호 입력없이 자동으로 로그인이 가능함.

1. TCP Socket descriptor 와 UDP Socket descriptor는 동일 하게 취급

#include <arpa/inet.h>
#include <sys/socket.h>
#include <unistd.h>
#include <iostream>
using namespace std;

int main(){
    int s1= socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
    cout<<" UDP SOCKET ID:"<<s1<<endl;

    int s2 = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    cout<<" TCP SOCKET ID:"<<s2<<endl;
    close(s1);

    int s3 = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    cout<<" TCP SOCKET ID:"<<s3<<endl;

    close(s2);
    close(s3);

    return 0;
    }

• 같은 descriptor 일지라도 완전히 다른 소켓이므로 다르다.

  2. 동시에 열 수 있는 descriptor 수

• TCP에서 동시에 열수 있는 descriptor수는 1024

• descriptor 수 조정 방법

  -$ ulimit -n 1023 // 1023으로 descriptor수 증가

  3. 연결 하지 않고 socket에 데이터 쓰기

  int s = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
   cout<<" TCP SOCKET ID:"<< s <<endl;
  
   char buf[1024];
   int r = send(s,buf,sizeof(buf),MSG_NOSIGNAL);

  • connect() 함수 없이 데이터를 쓴 경우 Broken Pipe(EPIPE) 로 실패. os가 강제로 프로세스 종료
  • 하지만, MSG_NOSIGNAL flag 가 종료 되는 것을 방지.

  4. 연결을 닫은 socket에 데이터 쓰기

  int s = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  cout<<" TCP SOCKET ID:"<< s <<endl;
  
  close(s);
  
  char buf[1024];
  int r = send(s,buf,sizeof(buf),MSG_NOSIGNAL);
  

• 소켓을 닫고 데이터를 보내려고하면 Bad file descripotr 에러 발생

• socket descriptor가 종료 되어있기 때문이다.(존재 하지 않음.)

  5. TCP 연결 후 데이터 전송 및 수신

  #include <arpa/inet.h>
  #include <errno.h>
  #include <string.h>
  #include <sys/socket.h>
  

#include <unistd.h> #include

using namespace std;

int main(){ int s = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); if(s < 0){ cerr<<"socket() failed: "<< strerror(errno)<<endl; return 1; }

struct sockaddr_in sin;
memset(&sin,0,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = inet_addr("127.0.0.1");
sin.sin_port = htons(10000);

//TCP connect()
if(connect(s,(struct sockaddr *)&sin, sizeof(sin)) < 0){
    cerr<<"connect() failed: "<< strerror(errno)<<endl;
    return 1;
}

char buf[1024];//데이터 보내기 1024bytes를 보낸 거임.
int r = send(s,buf,sizeof(buf),MSG_NOSIGNAL);
if(r < 0){
    cerr<<"send() failed: "<< strerror(errno)<<endl;}
else if(r == 0){
        cout<<"socket closed"<<endl;
}
else { 
    cout<<"Sent : "<<r<<"bytes"<<endl;
}

r = recv(s,buf,sizeof(buf),0); //데이터 수신하기

if(r < 0){
    cerr<<"recv() failed: "<< strerror(errno)<<endl;}
    else if(r == 0){
    cerr<<"Socket Closed"<< endl; //recv() ==0 일때 연결 끊김상태
    }
    else{ 
    cout<<"received : "<<r<<"bytes"<<endl;
    }
close(s);
return 0;

}

### 6. TCP active socket, passive socket
- active socket : 연결 맺어진 상태
> 클라이언트 : connect() 성공 뒤 socket
서버 : accept() 성공뒤 socket

- passive socket : 연결 맺기 전 대기상태
> 서버측 : listen() 성공뒤 socket

```cpp
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>

#include <unistd.h>
#include <iostream>

using namespace std;

int main(){
    int passiveSock = socket(AF_INET,SOCK_STREAM,0);

    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = htons(10000); //server 주소 포트번호


//bind() -> 클라이언트 i
    if(bind(passiveSock,(struct sockaddr *) &sin,sizeof(sin)) < 0) {
        cerr<< "bind() failed: "<< strerror(errno)<<endl;
        return 1;
    }

//listen() passive socket
    if(listen(passiveSock , 10) < 0){
        cerr<<"listen() failed: "<<strerror(errno)<<endl;
        return 1;
    }

//accept() activer socket
    memset(&sin,0,sizeof(sin));
    unsigned int sin_len = sizeof(sin);
    int clientSock = accept(passiveSock,(struct sockaddr *) &sin, &sin_len);

    if(clientSock <0){
        cerr<< "accept() failed: "<<strerror(errno)<<endl;
        return 1;
    }

//받을 데이터 버퍼 크기
    char buf[65536];
    int numrecv = recv(clientSock,buf,sizeof(buf),0); //recv()
    //recv() == 0 이면 연결이 끊긴다
    if(numrecv == 0){
            cout<<"Socket closed"<<clientSock<< endl;
        }
        else if(numrecv < 0){
            cerr<<"recv() failed: "<<strerror(errno)<<endl;
        }
        else { 
        cout<<"received : "<<numrecv<<"bytes , cliendsock"<< clientSock <<endl;
        }

        int offset = 0;
        while(offset < numrecv){
            int numSend = send(clientSock, buf+offset, numrecv - offset,0);

            if(numSend < 0){
                cerr<< "send() failed: "<<strerror(errno)<<endl;
            }else{
                cout<< "Sent: "<<numSend <<endl;
                offset += numSend;
            }
        }
        close(clientSock);
        close(passiveSock);
}

• UDP vs TCP
• -
• UDP 서버 소켓 개수 -> 1개
• TCP 서버 소켓 개수 -> 새로운 클라이언트 접속 passive socket, 클라이언트와 통신할 수 있는 actvie socket은 클라이언트 개수 만큼 필요.

- UDP 보다 TCP 가 훨씬 많은 os 부하 발생.