Tôi đang xây dựng một ứng dụng web với khung lò xo [-> java]. Vì lý do kiểm tra, tôi đã tạo một người dùng [thông qua câu lệnh SQL]. Hiện tại tôi đang làm việc trên mã hóa mật khẩu, mà tôi đang sử dụng bcyrptpasswordencoder. Tôi đang tự hỏi, nếu có thể, để tạo người dùng đầu tiên này bằng mật khẩu được mã hóa.
Nói cách khác: Tôi có thể tạo một người dùng mới thông qua câu lệnh SQL bằng cách sử dụng mật khẩu được mã hóa làm đầu vào không? Nếu vậy, làm thế nào để tôi nhập mật khẩu được mã hóa?
Tôi đã thử {bcyrpt} [băm], mà tôi đã đọc trên một số trang web, nhưng điều đó dường như không hoạt động ...
Chèn các giá trị người dùng [tên người dùng, mật khẩu] ['quản trị', 'passwd']]
Đã hỏi ngày 26 tháng 12 năm 2018 lúc 16:18Dec 26, 2018 at 16:18
Đầu tiên là một sự làm rõ nhanh chóng về thuật ngữ. Mật khẩu được "băm" với bcrypt không "được mã hóa". Điều này có nghĩa là nó là một thuật toán một chiều [bạn không thể bỏ giá trị].
Giá trị được lưu trữ trong cơ sở dữ liệu là giá trị băm [ví dụ: $2a$10$Iewuj5kQFVnUaNbb6M0sAu6a1qbc5bqXAuyc.9fF4cR8xxIOhD0Da
] chứ không phải mật khẩu văn bản đơn giản.
Vì vậy, tất cả những gì bạn cần làm cho người dùng thử nghiệm của bạn là tạo blh bcrypt để đưa vào câu lệnh chèn. Hoặc chạy nó thông qua BCryptPasswordEncoder
hoặc sử dụng trình tạo BCRYPT trực tuyến.
Ví dụ:
INSERT INTO USER[USERNAME, PASSWORD] VALUES ['admin', '$2a$10$Iewuj5kQFVnUaNbb6M0sAu6a1qbc5bqXAuyc.9fF4cR8xxIOhD0Da']
Đã trả lời ngày 26 tháng 12 năm 2018 lúc 17:05Dec 26, 2018 at 17:05
Micah Carrickmicah CarrickMicah Carrick
9.7173 huy hiệu vàng30 Huy hiệu bạc41 Huy hiệu đồng3 gold badges30 silver badges41 bronze badges
Bạn có thể sử dụng chú thích
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
0 để gọi mã sau khi khởi động mùa xuân và thêm người dùng bằng mật khẩu được mã hóa. Nhưng tôi khuyến khích bạn chỉ viết một bài kiểm tra đơn vị. :] @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
Đã trả lời ngày 26 tháng 12 năm 2018 lúc 22:48Dec 26, 2018 at 22:48
Jakub Pomykałajakub PomykałaJakub Pomykała
1.9843 huy hiệu vàng25 Huy hiệu bạc55 Huy hiệu đồng3 gold badges25 silver badges55 bronze badges
2.2.4 & nbsp; mật khẩu băm trong MySQL
Ghi chú
Thông tin trong phần này chỉ áp dụng đầy đủ trước MySQL 5.7.5 và chỉ cho các tài khoản sử dụng các plugin xác thực
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
1 hoặc @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
2. Hỗ trợ băm mật khẩu trước 4,1 đã bị xóa trong MySQL 5.7.5. Điều này bao gồm loại bỏ plugin xác thực @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
2 và hàm @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
4. Ngoài ra, @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
5 không thể bị vô hiệu hóa và @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
6 không thể được đặt thành 1.Kể từ MySQL 5.7.5, chỉ có thông tin về các băm mật khẩu 4.1 và plugin xác thực
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
1 vẫn có liên quan.MySQL liệt kê các tài khoản người dùng trong bảng
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
8 của cơ sở dữ liệu @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
9. Mỗi tài khoản MySQL có thể được gán một mật khẩu, mặc dù bảng @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
8 không lưu trữ phiên bản Cleartext của mật khẩu, nhưng giá trị băm được tính toán từ nó.MySQL sử dụng mật khẩu trong hai giai đoạn giao tiếp máy khách/máy chủ:
Khi khách hàng cố gắng kết nối với máy chủ, có một bước xác thực ban đầu trong đó máy khách phải trình bày mật khẩu có giá trị băm phù hợp với giá trị băm được lưu trong bảng
8 cho tài khoản mà máy khách muốn sử dụng.@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
Sau khi khách hàng kết nối, nó có thể [nếu nó có đủ đặc quyền] đã đặt hoặc thay đổi mật khẩu băm cho các tài khoản được liệt kê trong bảng
8. Máy khách có thể làm điều này bằng cách sử dụng hàm@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
3 để tạo băm mật khẩu hoặc bằng cách sử dụng câu lệnh tạo mật khẩu [mysql> SELECT PASSWORD['mypass']; +--------------------+ | PASSWORD['mypass'] | +--------------------+ | 6f8c114b58f2ce9e | +--------------------+
4,mysql> SELECT PASSWORD['mypass']; +--------------------+ | PASSWORD['mypass'] | +--------------------+ | 6f8c114b58f2ce9e | +--------------------+
5 hoặcmysql> SELECT PASSWORD['mypass']; +--------------------+ | PASSWORD['mypass'] | +--------------------+ | 6f8c114b58f2ce9e | +--------------------+
6].mysql> SELECT PASSWORD['mypass']; +--------------------+ | PASSWORD['mypass'] | +--------------------+ | 6f8c114b58f2ce9e | +--------------------+
Nói cách khác, máy chủ kiểm tra các giá trị băm trong quá trình xác thực khi máy khách lần đầu tiên cố gắng kết nối. Máy chủ tạo ra các giá trị băm nếu máy khách được kết nối gọi hàm
mysql> SELECT PASSWORD['mypass'];
+--------------------+
| PASSWORD['mypass'] |
+--------------------+
| 6f8c114b58f2ce9e |
+--------------------+
3 hoặc sử dụng câu lệnh tạo mật khẩu để đặt hoặc thay đổi mật khẩu.checks hash values during authentication when a client first attempts to connect. The server generates hash values
if a connected client invokes the mysql> SELECT PASSWORD['mypass'];
+--------------------+
| PASSWORD['mypass'] |
+--------------------+
| 6f8c114b58f2ce9e |
+--------------------+
3 function or uses a password-generating statement to set or change a password. Các phương thức băm mật khẩu trong MySQL có lịch sử được mô tả sau đây. Những thay đổi này được minh họa bằng các thay đổi trong kết quả từ hàm
mysql> SELECT PASSWORD['mypass'];
+--------------------+
| PASSWORD['mypass'] |
+--------------------+
| 6f8c114b58f2ce9e |
+--------------------+
3 tính toán các giá trị băm mật khẩu và trong cấu trúc của bảng @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
8 nơi lưu trữ mật khẩu.Phương thức băm bản gốc [trước 4,1]
Phương pháp băm ban đầu tạo ra một chuỗi 16 byte. Những băm như vậy trông như thế này:
mysql> SELECT PASSWORD['mypass'];
+--------------------+
| PASSWORD['mypass'] |
+--------------------+
| 6f8c114b58f2ce9e |
+--------------------+
Để lưu trữ mật khẩu tài khoản, cột
mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0 của bảng @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
8 tại thời điểm này dài 16 byte.Phương pháp băm 4.1
MySQL 4.1 đã giới thiệu mật khẩu băm cung cấp bảo mật tốt hơn và giảm nguy cơ mật khẩu bị chặn. Có một số khía cạnh cho sự thay đổi này:
Định dạng khác nhau của các giá trị mật khẩu được tạo bởi hàm
3mysql> SELECT PASSWORD['mypass']; +--------------------+ | PASSWORD['mypass'] | +--------------------+ | 6f8c114b58f2ce9e | +--------------------+
Mở rộng cột
0mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
Kiểm soát phương thức băm mặc định
Kiểm soát các phương thức băm được phép cho máy khách đang cố gắng kết nối với máy chủ
Những thay đổi trong MySQL 4.1 đã diễn ra trong hai giai đoạn:
MySQL 4.1.0 đã sử dụng phiên bản sơ bộ của phương thức băm 4.1. Phương pháp này đã tồn tại ngắn và các cuộc thảo luận sau đây không nói gì thêm về nó.
Trong MySQL 4.1.1, phương pháp băm đã được sửa đổi để tạo ra giá trị băm 41 byte dài hơn:
mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
Định dạng băm mật khẩu dài hơn có các thuộc tính mật mã tốt hơn và xác thực máy khách dựa trên các băm dài an toàn hơn so với các băm ngắn cũ hơn.
Để phù hợp với các băm mật khẩu dài hơn, cột
0 trong bảngmysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
8 đã được thay đổi tại thời điểm này thành 41 byte, độ dài hiện tại của nó.@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
Một cột
0 được mở rộng có thể lưu trữ các băm mật khẩu ở cả hai định dạng trước 4,1 và 4.1. Định dạng của bất kỳ giá trị băm nào có thể được xác định theo hai cách:mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
Độ dài: 4,1 và băm trước 4,1 lần lượt là 41 và 16 byte.
Các băm mật khẩu ở định dạng 4.1 luôn bắt đầu bằng ký tự
7, trong khi mật khẩu ở định dạng Pre-4.1 không bao giờ làm.mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
Để cho phép tạo ra các băm mật khẩu trước 4,1, hai thay đổi bổ sung đã được thực hiện:
Hàm
4 đã được thêm vào, trả về các giá trị băm ở định dạng 16 byte.@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
Đối với mục đích tương thích, biến hệ thống
6 đã được thêm vào, để cho phép DBA và các ứng dụng kiểm soát phương thức băm. Giá trị@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
6 mặc định là 0 Nguyên nhân băm sử dụng phương thức 4.1 [giá trị băm 41 byte], nhưng cài đặt@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
1 gây ra băm để sử dụng phương thức pre-4.1. Trong trường hợp này,$> mysql -h localhost -u root Client does not support authentication protocol requested by server; consider upgrading MySQL client
3 tạo ra các giá trị 16 byte và tương đương vớimysql> SELECT PASSWORD['mypass']; +--------------------+ | PASSWORD['mypass'] | +--------------------+ | 6f8c114b58f2ce9e | +--------------------+
4@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
Để cho phép kiểm soát DBA về cách khách hàng được phép kết nối, biến hệ thống
5 đã được thêm vào. Khởi động máy chủ với biến đã bị vô hiệu hóa hoặc được bật giấy phép hoặc cấm máy khách kết nối bằng phương thức băm mật khẩu trước 4 tuổi cũ hơn. Trước MySQL 5.6.5,@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
5 bị tắt theo mặc định. Tính đến 5.6.5,@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
5 được bật theo mặc định để quảng bá một cấu hình mặc định an toàn hơn DBA có thể vô hiệu hóa nó theo quyết định của chúng, nhưng điều này không được khuyến nghị và các băm mật khẩu trước 4,1 được không dùng nữa và nên tránh. .@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
Ngoài ra, máy khách MySQL hỗ trợ tùy chọn
7 tương tự như$> mysql -h localhost -u root Client does not support authentication protocol requested by server; consider upgrading MySQL client
5, nhưng từ phía máy khách. Nó có thể được sử dụng để ngăn chặn các kết nối với các tài khoản kém an toàn hơn sử dụng mật khẩu trước 4.1. Tùy chọn này bị tắt theo mặc định trước MySQL 5.6.7, được bật sau đó.mysql client supports a@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
7 option that is analogous to$> mysql -h localhost -u root Client does not support authentication protocol requested by server; consider upgrading MySQL client
5, but from the client side. It can be used to prevent connections to less secure accounts that use pre-4.1 password hashing. This option is disabled by default before MySQL 5.6.7, enabled thereafter.@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
Các vấn đề tương thích liên quan đến các phương pháp băm
Việc mở rộng cột
mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0 trong MySQL 4.1 từ 16 byte đến 41 byte ảnh hưởng đến các hoạt động cài đặt hoặc nâng cấp như sau:Nếu bạn thực hiện cài đặt mới của MySQL, cột
0 sẽ tự động thực hiện 41 byte.mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
Việc nâng cấp từ MySQL 4.1 trở lên các phiên bản hiện tại của MySQL không nên làm phát sinh bất kỳ vấn đề nào liên quan đến cột
0 vì cả hai phiên bản đều sử dụng cùng một phương thức băm mật khẩu và độ dài cột.mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
Để nâng cấp từ bản phát hành trước 4,1 lên 4.1 trở lên, bạn phải nâng cấp các bảng hệ thống sau khi nâng cấp. [Xem mysql_upgrade - kiểm tra và nâng cấp bảng MySQL.]
Phương thức băm 4.1 chỉ được hiểu bởi các máy chủ và máy khách MySQL 4.1 [và cao hơn], có thể dẫn đến một số vấn đề tương thích. Máy khách 4.1 hoặc cao hơn có thể kết nối với máy chủ Pre-4.1, vì máy khách hiểu cả các phương thức băm mật khẩu trước 4,1 và 4.1. Tuy nhiên, máy khách Pre-4.1 cố gắng kết nối với máy chủ 4.1 hoặc cao hơn có thể gặp khó khăn. Ví dụ: máy khách MySQL 4.0 có thể thất bại với thông báo lỗi sau:mysql client may fail with the following error message:
$> mysql -h localhost -u root
Client does not support authentication protocol requested
by server; consider upgrading MySQL client
Cuộc thảo luận sau đây mô tả sự khác biệt giữa các phương thức băm trước 4,1 và 4.1 và những gì bạn nên làm nếu bạn nâng cấp máy chủ của mình nhưng cần duy trì khả năng tương thích ngược với máy khách trước 4,1. .
Sự khác biệt giữa băm mật khẩu ngắn và dài có liên quan đến cách máy chủ sử dụng mật khẩu trong quá trình xác thực và cách nó tạo băm mật khẩu cho các máy khách được kết nối thực hiện các hoạt động thay đổi mật khẩu.
Cách mà máy chủ sử dụng băm mật khẩu trong quá trình xác thực bị ảnh hưởng bởi chiều rộng của cột
mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0:Nếu cột ngắn, chỉ sử dụng xác thực hash ngắn.
Nếu cột dài, nó có thể giữ các băm ngắn hoặc dài và máy chủ có thể sử dụng định dạng:
Các máy khách Pre-4.1 có thể kết nối, nhưng vì họ chỉ biết về phương thức băm trước 4.1, họ chỉ có thể xác thực bằng cách sử dụng các tài khoản có băm ngắn.
4.1 và các máy khách sau này có thể xác thực bằng cách sử dụng các tài khoản có băm ngắn hoặc dài.
Ngay cả đối với các tài khoản hash ngắn, quy trình xác thực thực sự an toàn hơn một chút cho các máy khách 4.1 và sau đó so với các khách hàng lớn tuổi. Về mặt bảo mật, độ dốc từ ít nhất đến an toàn nhất là:
Pre-4.1 máy khách xác thực bằng mật khẩu ngắn
4.1 hoặc sau đó máy khách xác thực bằng mật khẩu ngắn
4.1 hoặc sau đó máy khách xác thực bằng mật khẩu dài
Cách mà máy chủ tạo ra băm mật khẩu cho các máy khách được kết nối bị ảnh hưởng bởi chiều rộng của cột
mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0 và biến hệ thống @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
6. Máy chủ 4.1 trở lên chỉ tạo các băm dài nếu đáp ứng một số điều kiện nhất định: cột mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0 phải đủ rộng để giữ các giá trị dài và không được đặt thành 1.Những điều kiện áp dụng như sau:
Cột
0 phải đủ rộng để giữ các băm dài [41 byte]. Nếu cột chưa được cập nhật và vẫn có chiều rộng trước 4,1 byte, thì máy chủ thông báo rằng băm dài không thể phù hợp với nó và chỉ tạo các băm ngắn khi máy khách thực hiện các hoạt động thay đổi mật khẩu bằng hàmmysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
3 hoặc mật khẩu- Tạo tuyên bố. Đây là hành vi xảy ra nếu bạn đã nâng cấp từ phiên bản MySQL cũ hơn 4.1 lên 4.1 trở lên nhưng chưa chạy chương trình MySQL_Upgrade để mở rộng cộtmysql> SELECT PASSWORD['mypass']; +--------------------+ | PASSWORD['mypass'] | +--------------------+ | 6f8c114b58f2ce9e | +--------------------+
0.mysql_upgrade program to widen themysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
0 column.mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
Nếu cột
0 rộng, nó có thể lưu trữ các băm mật khẩu ngắn hoặc dài. Trong trường hợp này, các câu lệnhmysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
3 và các câu lệnh tạo mật khẩu tạo ra các băm dài trừ khi máy chủ được bắt đầu với biến hệ thốngmysql> SELECT PASSWORD['mypass']; +--------------------+ | PASSWORD['mypass'] | +--------------------+ | 6f8c114b58f2ce9e | +--------------------+
6 được đặt thành 1 để buộc máy chủ tạo ra các băm mật khẩu ngắn thay thế.@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
Mục đích của biến hệ thống
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
6 là cho phép khả năng tương thích ngược với máy khách trước 4,1 trong trường hợp máy chủ sẽ tạo ra các băm mật khẩu dài. Tùy chọn không ảnh hưởng đến xác thực [4.1 và các máy khách sau này vẫn có thể sử dụng các tài khoản có băm mật khẩu dài], nhưng nó ngăn chặn việc tạo mật khẩu dài băm trong bảng @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
8 do kết quả của hoạt động thay đổi mật khẩu. Điều đó được phép xảy ra, tài khoản không còn có thể được sử dụng bởi các máy khách trước 4,1. Với @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
6 bị vô hiệu hóa, có thể có kịch bản không mong muốn sau đây:Máy khách Pre-4.1 cũ kết nối với tài khoản có hàm băm mật khẩu ngắn.
Khách hàng thay đổi mật khẩu của riêng mình. Với
6 bị vô hiệu hóa, điều này dẫn đến tài khoản có hàm băm mật khẩu dài.@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
Lần tới khi khách hàng cũ cố gắng kết nối với tài khoản, không thể, vì tài khoản có hàm băm mật khẩu dài yêu cầu phương thức băm 4.1 trong quá trình xác thực. .
Kịch bản này minh họa rằng, nếu bạn phải hỗ trợ các máy khách Pre-4.1 cũ hơn, có vấn đề là chạy máy chủ 4.1 hoặc cao hơn mà không cần
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
6 được đặt thành 1. Bằng cách chạy máy chủ bằng $> mysql -h localhost -u root
Client does not support authentication protocol requested
by server; consider upgrading MySQL client
1, các hoạt động thay đổi mật khẩu không tạo ra băm mật khẩu dài và do đó Không làm cho các tài khoản trở nên không thể truy cập được đối với các khách hàng lớn tuổi. .Nhược điểm của
$> mysql -h localhost -u root
Client does not support authentication protocol requested
by server; consider upgrading MySQL client
1 là bất kỳ mật khẩu nào được tạo hoặc thay đổi sử dụng các băm ngắn, thậm chí đối với các máy khách 4.1 trở lên. Vì vậy, bạn mất bảo mật bổ sung được cung cấp bởi các băm mật khẩu dài. Để tạo một tài khoản có hàm băm dài [ví dụ: để sử dụng cho máy khách 4.1] hoặc để thay đổi tài khoản hiện có để sử dụng hàm băm mật khẩu dài, quản trị viên có thể đặt giá trị phiên là @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
6 được đặt thành 0 trong khi để lại bộ giá trị toàn cầu đến 1:mysql> SET @@SESSION.old_passwords = 0;
Query OK, 0 rows affected [0.00 sec]
mysql> SELECT @@SESSION.old_passwords, @@GLOBAL.old_passwords;
+-------------------------+------------------------+
| @@SESSION.old_passwords | @@GLOBAL.old_passwords |
+-------------------------+------------------------+
| 0 | 1 |
+-------------------------+------------------------+
1 row in set [0.00 sec]
mysql> CREATE USER 'newuser'@'localhost' IDENTIFIED BY 'newpass';
Query OK, 0 rows affected [0.03 sec]
mysql> SET PASSWORD FOR 'existinguser'@'localhost' = PASSWORD['existingpass'];
Query OK, 0 rows affected [0.00 sec]
Các kịch bản sau đây là có thể trong MySQL 4.1 trở lên. Các yếu tố là liệu cột
mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0 ngắn hay dài, và, nếu lâu, liệu máy chủ được bắt đầu với @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
6 được bật hay tắt. Kịch bản 1: Cột ngắn
0 trong bảng người dùng: Short mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0 column in user table: Chỉ có thể lưu trữ các băm ngắn trong cột
0.mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
Máy chủ chỉ sử dụng các băm ngắn trong xác thực máy khách.
Đối với các máy khách được kết nối, các hoạt động tạo băm mật khẩu liên quan đến chức năng
3 hoặc các câu lệnh tạo mật khẩu sử dụng các băm ngắn. Bất kỳ thay đổi nào đối với mật khẩu của tài khoản đều dẫn đến tài khoản đó có hàm băm mật khẩu ngắn.mysql> SELECT PASSWORD['mypass']; +--------------------+ | PASSWORD['mypass'] | +--------------------+ | 6f8c114b58f2ce9e | +--------------------+
Giá trị của
6 là không liên quan vì với cột@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
0 ngắn, máy chủ chỉ tạo ra băm mật khẩu ngắn.mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
Kịch bản này xảy ra khi cài đặt Pre-4.1 MySQL đã được nâng cấp lên 4.1 trở lên nhưng MySQL_Upgrade chưa được chạy để nâng cấp các bảng hệ thống trong cơ sở dữ liệu
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
9. [Đây không phải là cấu hình được đề xuất vì nó không cho phép sử dụng mật khẩu 4.1 an toàn hơn.]mysql_upgrade has not been run to upgrade the system tables in the @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
9 database. [This is not a recommended configuration because it does not permit use of more secure 4.1 password hashing.] Kịch bản 2: Cột dài
0; Máy chủ bắt đầu với mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
1: Long $> mysql -h localhost -u root
Client does not support authentication protocol requested
by server; consider upgrading MySQL client
mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0 column; server started with $> mysql -h localhost -u root
Client does not support authentication protocol requested
by server; consider upgrading MySQL client
1: -
Các băm ngắn hoặc dài có thể được lưu trữ trong cột
0.mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
4.1 và các máy khách sau này có thể xác thực cho các tài khoản có băm ngắn hoặc dài.
Khách hàng trước 4,1 chỉ có thể xác thực cho các tài khoản có băm ngắn.
Đối với các máy khách được kết nối, các hoạt động tạo băm mật khẩu liên quan đến chức năng
3 hoặc các câu lệnh tạo mật khẩu sử dụng các băm ngắn. Bất kỳ thay đổi nào đối với mật khẩu của tài khoản đều dẫn đến tài khoản đó có hàm băm mật khẩu ngắn.mysql> SELECT PASSWORD['mypass']; +--------------------+ | PASSWORD['mypass'] | +--------------------+ | 6f8c114b58f2ce9e | +--------------------+
Giá trị của
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
6 là không liên quan vì với cột mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0 ngắn, máy chủ chỉ tạo ra băm mật khẩu ngắn.Kịch bản này xảy ra khi cài đặt Pre-4.1 MySQL đã được nâng cấp lên 4.1 trở lên nhưng MySQL_Upgrade chưa được chạy để nâng cấp các bảng hệ thống trong cơ sở dữ liệu
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
9. [Đây không phải là cấu hình được đề xuất vì nó không cho phép sử dụng mật khẩu 4.1 an toàn hơn.]Kịch bản 2: Cột dài
mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0; Máy chủ bắt đầu với $> mysql -h localhost -u root
Client does not support authentication protocol requested
by server; consider upgrading MySQL client
1: Các băm ngắn hoặc dài có thể được lưu trữ trong cột
0. Long mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
mysql> SELECT PASSWORD['mypass'];
+-------------------------------------------+
| PASSWORD['mypass'] |
+-------------------------------------------+
| *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 |
+-------------------------------------------+
0
column; server started with $2a$10$Iewuj5kQFVnUaNbb6M0sAu6a1qbc5bqXAuyc.9fF4cR8xxIOhD0Da
8: Các băm ngắn hoặc dài có thể được lưu trữ trong cột
0.mysql> SELECT PASSWORD['mypass']; +-------------------------------------------+ | PASSWORD['mypass'] | +-------------------------------------------+ | *6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4 | +-------------------------------------------+
4.1 và các máy khách sau này có thể xác thực cho các tài khoản có băm ngắn hoặc dài.
Khách hàng trước 4,1 chỉ có thể xác thực cho các tài khoản có băm ngắn.
Trong kịch bản này, các tài khoản mới được tạo có băm mật khẩu ngắn vì
1 ngăn chặn việc tạo các băm dài. Ngoài ra, nếu bạn tạo một tài khoản có hàm băm dài trước khi đặt$> mysql -h localhost -u root Client does not support authentication protocol requested by server; consider upgrading MySQL client
6 thành 1, thay đổi mật khẩu của tài khoản trong khi@Autowired private PasswordEncoder passwordEncoder; @Autowired private UserRepository userRepository; @PostConstruct public void addFirstUser[]{ User user = new User["", passwordEncoder.encode["some-password"]]; userRepository.save[user]; }
1 dẫn đến tài khoản được cung cấp mật khẩu ngắn, khiến nó mất lợi ích bảo mật của băm dài hơn.$> mysql -h localhost -u root Client does not support authentication protocol requested by server; consider upgrading MySQL client
Để tạo một tài khoản mới có hàm băm mật khẩu dài hoặc để thay đổi mật khẩu của bất kỳ tài khoản hiện có nào để sử dụng băm dài, trước tiên hãy đặt giá trị phiên là
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
6 được đặt thành 0 trong khi để lại giá trị toàn cầu được đặt thành 1, như được mô tả trước đây.Nếu đây là một vấn đề, bạn có thể thay đổi mật khẩu theo một cách đặc biệt. Ví dụ: thông thường bạn sử dụng BCryptPasswordEncoder
5 như sau để thay đổi mật khẩu tài khoản:
SET PASSWORD FOR 'some_user'@'some_host' = PASSWORD['password'];
Để thay đổi mật khẩu nhưng hãy tạo một hàm băm ngắn, hãy sử dụng chức năng
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
4 thay thế:SET PASSWORD FOR 'some_user'@'some_host' = OLD_PASSWORD['password'];
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
4 rất hữu ích cho các tình huống trong đó bạn rõ ràng muốn tạo ra một hàm băm ngắn.Nhược điểm cho từng kịch bản trước đó có thể được tóm tắt như sau:
Trong kịch bản 1, bạn không thể tận dụng các băm dài hơn cung cấp xác thực an toàn hơn.
Trong Kịch bản 2,
$> mysql -h localhost -u root
Client does not support authentication protocol requested
by server; consider upgrading MySQL client
1 ngăn các tài khoản có băm ngắn không thể truy cập được, nhưng các hoạt động thay đổi mật khẩu khiến các tài khoản có băm dài để trở lại băm ngắn trừ khi bạn cẩn thận thay đổi giá trị phiên là @Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
6 thành 0 trước tiên.Trong Kịch bản 3, các tài khoản có băm ngắn trở nên không thể truy cập được đối với máy khách trước 4,1 nếu bạn thay đổi mật khẩu mà không sử dụng rõ ràng
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private UserRepository userRepository;
@PostConstruct
public void addFirstUser[]{
User user = new User["", passwordEncoder.encode["some-password"]];
userRepository.save[user];
}
4.Cách tốt nhất để tránh các vấn đề tương thích liên quan đến băm mật khẩu ngắn là không sử dụng chúng:
Nâng cấp tất cả các chương trình khách hàng lên MySQL 4.1 trở lên.
Chạy máy chủ với
$2a$10$Iewuj5kQFVnUaNbb6M0sAu6a1qbc5bqXAuyc.9fF4cR8xxIOhD0Da
8.Đặt lại mật khẩu cho bất kỳ tài khoản nào bằng băm mật khẩu ngắn để sử dụng băm mật khẩu dài.
Để bảo mật bổ sung, hãy chạy máy chủ với
$2a$10$Iewuj5kQFVnUaNbb6M0sAu6a1qbc5bqXAuyc.9fF4cR8xxIOhD0Da
9.