Bạn có nên bảo vệ chống lại các giá trị bất ngờ từ các API bên ngoài?

Hãy nói rằng bạn đang mã hóa một chức năng lấy đầu vào từ API bên ngoài MyAPI.

API bên ngoài đó MyAPIcó một hợp đồng tuyên bố rằng nó sẽ trả lại một stringhoặc a number.

Là nó khuyến khích để bảo vệ chống lại những thứ như null, undefined, booleanvv mặc dù nó không phải là một phần của API MyAPI? Cụ thể, vì bạn không có quyền kiểm soát API đó, bạn không thể đảm bảo thông qua một cái gì đó như phân tích kiểu tĩnh để an toàn hơn là xin lỗi?

Tôi đang suy nghĩ liên quan đến Nguyên tắc Mạnh mẽ .

Bạn không bao giờ nên tin tưởng đầu vào cho phần mềm của mình, bất kể nguồn nào. Không chỉ xác nhận các loại là quan trọng, mà còn phạm vi đầu vào và logic kinh doanh là tốt. Mỗi bình luận, điều này được mô tả tốt bởi OWASP

Không làm như vậy tốt nhất sẽ để lại cho bạn dữ liệu rác mà sau này bạn phải dọn sạch, nhưng tệ nhất là bạn sẽ để lại cơ hội khai thác độc hại nếu dịch vụ ngược dòng đó bị xâm phạm theo cách nào đó (qv hack Target). Một loạt các vấn đề ở giữa bao gồm việc đưa ứng dụng của bạn vào trạng thái không thể phục hồi.

Từ các bình luận tôi có thể thấy rằng có lẽ câu trả lời của tôi có thể sử dụng một chút mở rộng.

Bằng cách "không bao giờ tin vào đầu vào", tôi chỉ đơn giản là bạn không thể cho rằng bạn sẽ luôn nhận được thông tin hợp lệ và đáng tin cậy từ các hệ thống ngược dòng hoặc hạ nguồn, và do đó bạn nên luôn vệ sinh đầu vào đó với khả năng tốt nhất của mình hoặc từ chối nó

Một đối số nổi lên trong các ý kiến ​​tôi sẽ giải quyết bằng ví dụ. Mặc dù có, bạn phải tin tưởng hệ điều hành của mình ở một mức độ nào đó, chẳng hạn, không hợp lý, từ chối kết quả của trình tạo số ngẫu nhiên nếu bạn yêu cầu nó cho số từ 1 đến 10 và nó trả lời bằng "bob".

Tương tự, trong trường hợp của OP, bạn chắc chắn nên đảm bảo ứng dụng của mình chỉ chấp nhận đầu vào hợp lệ từ dịch vụ ngược dòng. Những gì bạn làm khi không ổn là tùy thuộc vào bạn và phụ thuộc rất nhiều vào chức năng kinh doanh thực tế mà bạn đang cố gắng thực hiện, nhưng tối thiểu bạn sẽ đăng nhập nó để gỡ lỗi sau và nếu không thì đảm bảo rằng ứng dụng của bạn không hoạt động vào trạng thái không thể phục hồi hoặc không an toàn.

Mặc dù bạn không bao giờ có thể biết mọi đầu vào có thể có ai đó / thứ gì đó có thể cung cấp cho bạn, nhưng bạn chắc chắn có thể giới hạn những gì được phép dựa trên yêu cầu kinh doanh và thực hiện một số hình thức danh sách trắng đầu vào dựa trên điều đó.

Vâng , tất nhiên. Nhưng điều gì khiến bạn nghĩ rằng câu trả lời có thể khác nhau?

Bạn chắc chắn không muốn để chương trình của mình hoạt động theo một cách không thể đoán trước trong trường hợp API không trả lại những gì hợp đồng nói, phải không? Vì vậy, ít nhất bạn phải đối phó với một hành vi như vậy bằng cách nào đó . Một hình thức xử lý lỗi tối thiểu luôn luôn xứng đáng với nỗ lực (rất tối thiểu!) Và hoàn toàn không có lý do gì để không thực hiện một cái gì đó như thế này.

Tuy nhiên, bạn nên đầu tư bao nhiêu nỗ lực để giải quyết một trường hợp như vậy phụ thuộc rất nhiều vào trường hợp và chỉ có thể được trả lời trong bối cảnh hệ thống của bạn. Thông thường, một mục nhật ký ngắn và để ứng dụng kết thúc một cách duyên dáng có thể là đủ. Đôi khi, bạn sẽ tốt hơn khi thực hiện một số xử lý ngoại lệ chi tiết, xử lý các dạng khác nhau của các giá trị trả về "sai" và có thể phải thực hiện một số chiến lược dự phòng.

Nhưng nó sẽ tạo ra sự khác biệt nếu bạn chỉ viết một số ứng dụng định dạng bảng tính đường phố, được sử dụng bởi ít hơn 10 người và trong đó tác động tài chính của một vụ tai nạn ứng dụng là khá thấp hoặc nếu bạn đang tạo ra một lái xe tự trị mới hệ thống, nơi một sự cố ứng dụng có thể phải trả giá.

Vì vậy, không có lối tắt chống lại việc phản ánh về những gì bạn đang làm , sử dụng ý thức chung của bạn luôn luôn là bắt buộc.

Nguyên tắc mạnh mẽ - cụ thể, "tự do trong những gì bạn chấp nhận" một nửa - là một ý tưởng rất tồi trong phần mềm. Ban đầu nó được phát triển trong bối cảnh phần cứng, trong đó các ràng buộc vật lý làm cho dung sai kỹ thuật trở nên rất quan trọng, nhưng trong phần mềm, khi ai đó gửi cho bạn không đúng định dạng hoặc đầu vào không đúng, bạn có hai lựa chọn. Bạn có thể từ chối nó, (tốt nhất là với một lời giải thích về những gì đã sai,) hoặc bạn có thể cố gắng tìm ra ý nghĩa của nó.

EDIT: Hóa ra tôi đã nhầm trong tuyên bố trên. Nguyên lý mạnh mẽ không đến từ thế giới phần cứng, mà từ kiến ​​trúc Internet, cụ thể là RFC 1958 . Nó nói:

3.9 Hãy nghiêm khắc khi gửi và khoan dung khi nhận. Việc triển khai phải tuân theo các thông số kỹ thuật chính xác khi gửi tới mạng và chấp nhận đầu vào bị lỗi từ mạng. Khi nghi ngờ, hãy loại bỏ đầu vào bị lỗi một cách im lặng, mà không trả lại thông báo lỗi trừ khi thông số kỹ thuật này được yêu cầu.

Điều này nói một cách đơn giản, đơn giản là sai từ đầu đến cuối. Thật khó để hình dung ra một khái niệm sai lầm hơn về xử lý lỗi hơn là "loại bỏ đầu vào bị lỗi một cách im lặng mà không trả về một thông báo lỗi", vì những lý do được đưa ra trong bài viết này.

Xem thêm bài viết của IETF Hậu quả có hại của Nguyên tắc Mạnh mẽ để biết thêm chi tiết về điểm này.

Không bao giờ, không bao giờ, không bao giờ chọn tùy chọn thứ hai đó trừ khi bạn có tài nguyên tương đương với nhóm Tìm kiếm của Google để thực hiện dự án của mình, bởi vì đó là những gì cần có để đưa ra một chương trình máy tính thực hiện bất kỳ công việc nào phù hợp với lĩnh vực cụ thể đó. (Và thậm chí sau đó, các đề xuất của Google có cảm giác như họ đi ra khỏi trường bên trái khoảng một nửa thời gian.) Nếu bạn cố gắng làm như vậy, điều bạn sẽ gặp phải là một vấn đề đau đầu mà chương trình của bạn sẽ thường xuyên cố gắng diễn giải đầu vào xấu như X, khi ý nghĩa thực sự của người gửi là Y.

Điều này là xấu vì hai lý do. Một điều hiển nhiên là vì sau đó bạn có dữ liệu xấu trong hệ thống của mình. Một điều ít rõ ràng hơn là trong nhiều trường hợp, cả bạn và người gửi đều không nhận ra rằng bất cứ điều gì đã xảy ra cho đến tận sau này khi có thứ gì đó nổ tung trên mặt bạn, và rồi đột nhiên bạn có một mớ hỗn độn lớn, đắt tiền để khắc phục và không biết những gì đã đi sai bởi vì hiệu quả đáng chú ý là cho đến nay đã được loại bỏ khỏi nguyên nhân gốc rễ.

Đây là lý do tại sao nguyên tắc Fail Fast tồn tại; cứu mọi người liên quan đến vấn đề đau đầu bằng cách áp dụng nó vào API của bạn.

Nói chung, mã phải được xây dựng để duy trì ít nhất các ràng buộc sau bất cứ khi nào thực tế:

1. Khi đưa ra đầu vào chính xác, sản xuất đầu ra chính xác.

2. Khi được cung cấp đầu vào hợp lệ (có thể đúng hoặc không chính xác), hãy tạo đầu ra hợp lệ (tương tự).

3. Khi được cung cấp đầu vào không hợp lệ, hãy xử lý nó mà không có bất kỳ tác dụng phụ nào ngoài những tác động gây ra bởi đầu vào thông thường hoặc những tác nhân được xác định là báo hiệu lỗi.

Trong nhiều tình huống, các chương trình về cơ bản sẽ chuyển qua các khối dữ liệu khác nhau mà không quan tâm đặc biệt đến việc chúng có hợp lệ hay không. Nếu các đoạn như vậy xảy ra để chứa dữ liệu không hợp lệ, thì kết quả đầu ra của chương trình có thể chứa dữ liệu không hợp lệ. Trừ khi một chương trình được thiết kế đặc biệt để xác thực tất cả dữ liệu và đảm bảo rằng nó sẽ không tạo ra đầu ra không hợp lệ ngay cả khi được cung cấp đầu vào không hợp lệ , các chương trình xử lý đầu ra của nó sẽ cho phép khả năng dữ liệu không hợp lệ trong đó.

Mặc dù xác nhận dữ liệu sớm thường là mong muốn, nhưng nó không phải lúc nào cũng thực tế. Trong số những điều khác, nếu tính hợp lệ của một đoạn dữ liệu phụ thuộc vào nội dung của các đoạn dữ liệu khác và nếu phần lớn dữ liệu được đưa vào một số bước sẽ được lọc theo cách đó, hạn chế xác thực dữ liệu đi qua tất cả các giai đoạn có thể mang lại hiệu suất tốt hơn nhiều so với cố gắng xác nhận mọi thứ.

Hơn nữa, ngay cả khi một chương trình được chỉ dự kiến sẽ được đưa ra dữ liệu được xác thực trước, nó thường tốt để có nó duy trì những hạn chế nêu trên nào bất cứ khi nào thực tế. Lặp đi lặp lại xác nhận đầy đủ ở mỗi bước xử lý thường sẽ là một sự tiêu hao hiệu suất lớn, nhưng số lượng xác nhận hạn chế cần thiết để duy trì các ràng buộc trên có thể rẻ hơn nhiều.

Hãy so sánh hai kịch bản và cố gắng đưa ra kết luận.

Kịch bản 1 Ứng dụng của chúng tôi giả định API bên ngoài sẽ hoạt động theo thỏa thuận.

Kịch bản 2 Ứng dụng của chúng tôi giả định API bên ngoài có thể hoạt động sai, do đó thêm các biện pháp phòng ngừa.

Nói chung, có thể có bất kỳ API hoặc phần mềm nào vi phạm các thỏa thuận; có thể là do một lỗi hoặc điều kiện bất ngờ. Ngay cả một API có thể có vấn đề trong các hệ thống nội bộ dẫn đến kết quả không mong muốn.

Nếu chương trình của chúng tôi được viết với giả định API bên ngoài sẽ tuân thủ các thỏa thuận và tránh thêm bất kỳ biện pháp phòng ngừa nào; Ai sẽ là bên đối mặt với các vấn đề? Nó sẽ là chúng tôi, những người đã viết mã tích hợp.

Ví dụ: các giá trị null mà bạn đã chọn. Giả sử, theo thỏa thuận API, phản hồi phải có giá trị không null; nhưng nếu nó bị vi phạm đột ngột, chương trình của chúng tôi sẽ dẫn đến NPE.

Vì vậy, tôi tin rằng sẽ tốt hơn để đảm bảo ứng dụng của bạn có một số mã bổ sung để giải quyết các tình huống bất ngờ.

Bạn phải luôn xác thực dữ liệu đến - do người dùng nhập hoặc nếu không - vì vậy bạn nên có một quy trình xử lý khi dữ liệu được truy xuất từ ​​API bên ngoài này không hợp lệ.

Nói chung, bất kỳ đường may nào mà các hệ thống cực đại đáp ứng phải yêu cầu xác thực, ủy quyền (nếu không được xác định đơn giản bằng xác thực) và xác thực.

Nói chung, có, bạn phải luôn bảo vệ chống lại các đầu vào thiếu sót, nhưng tùy thuộc vào loại API, "bảo vệ" có nghĩa là những thứ khác nhau.

Đối với API bên ngoài cho máy chủ, bạn không muốn vô tình tạo một lệnh làm hỏng hoặc làm tổn hại trạng thái của máy chủ, vì vậy bạn phải bảo vệ chống lại điều đó.

Đối với một API như ví dụ một lớp container (danh sách, vectơ, v.v.), việc ném ngoại lệ là một kết quả hoàn toàn tốt, việc thỏa hiệp trạng thái của thể hiện của lớp có thể được chấp nhận ở một mức độ nào đó (ví dụ: một container được sắp xếp có toán tử so sánh bị lỗi sẽ không được sắp xếp), thậm chí làm hỏng ứng dụng có thể được chấp nhận, nhưng việc ảnh hưởng đến trạng thái của ứng dụng - ví dụ: ghi vào các vị trí bộ nhớ ngẫu nhiên không liên quan đến thể hiện của lớp - rất có thể là không.

Để đưa ra một ý kiến ​​hơi khác nhau: Tôi nghĩ rằng chỉ có thể chấp nhận làm việc với dữ liệu bạn được cung cấp, ngay cả khi nó vi phạm hợp đồng. Điều này phụ thuộc vào cách sử dụng: Đó là thứ gì đó PHẢI là một chuỗi cho bạn, hoặc đó là thứ bạn chỉ hiển thị / không sử dụng, v.v. Trong trường hợp sau, chỉ cần chấp nhận nó. Tôi có một API chỉ cần 1% dữ liệu được cung cấp bởi một api khác. Tôi không quan tâm đến loại dữ liệu nào trong 99%, vì vậy tôi sẽ không bao giờ kiểm tra nó.

Phải có sự cân bằng giữa "có lỗi vì tôi không kiểm tra đầu vào của mình đủ" và "Tôi từ chối dữ liệu hợp lệ vì tôi quá nghiêm ngặt".

Tôi đảm nhận việc này là luôn luôn, luôn kiểm tra từng đầu vào hệ thống của tôi. Điều đó có nghĩa là mọi tham số được trả về từ API phải được kiểm tra, ngay cả khi chương trình của tôi không sử dụng. Tôi cũng có xu hướng kiểm tra chính xác mọi thông số tôi gửi cho API. Chỉ có hai ngoại lệ cho quy tắc này, xem bên dưới.

Lý do để thử nghiệm là vì vì lý do nào đó, API / đầu vào không chính xác, chương trình của tôi không thể dựa vào bất cứ điều gì. Có lẽ chương trình của tôi đã được liên kết với một phiên bản API cũ, có gì đó khác với những gì tôi tin? Có lẽ chương trình của tôi vấp phải một lỗi trong chương trình bên ngoài chưa từng xảy ra trước đây. Hoặc thậm chí tệ hơn, xảy ra mọi lúc nhưng không ai quan tâm! Có lẽ chương trình bên ngoài đang bị tin tặc lừa để trả lại những thứ có thể làm tổn thương chương trình của tôi hoặc hệ thống?

Hai trường hợp ngoại lệ để kiểm tra mọi thứ trong thế giới của tôi là:

1. Hiệu suất sau khi đo lường hiệu suất cẩn thận:

   • không bao giờ tối ưu hóa trước khi bạn đo. Việc kiểm tra tất cả dữ liệu đầu vào / trả lại thường mất một thời gian rất nhỏ so với cuộc gọi thực tế vì vậy việc loại bỏ nó thường tiết kiệm rất ít hoặc không có gì. Tôi vẫn sẽ giữ mã phát hiện lỗi, nhưng nhận xét nó, có thể bằng macro hoặc đơn giản là nhận xét nó đi.

2. Khi bạn không biết phải làm gì với một lỗi

   • đôi khi, không thường xuyên, khi thiết kế của bạn đơn giản là không cho phép xử lý loại lỗi bạn sẽ tìm thấy. Có lẽ những gì bạn nên làm là đăng nhập một lỗi, nhưng không có lỗi đăng nhập trong hệ thống. Hầu như luôn luôn có thể tìm ra một số cách để "ghi nhớ" lỗi cho phép ít nhất bạn là nhà phát triển kiểm tra lỗi này sau đó. Bộ đếm lỗi là một điều tốt để có trong một hệ thống, ngay cả khi bạn chọn không đăng nhập.

Chính xác làm thế nào cẩn thận để kiểm tra giá trị đầu vào / trả lại là một câu hỏi quan trọng. Ví dụ: nếu API được cho là trả về một chuỗi, tôi sẽ kiểm tra xem:

• kiểu dữ liệu Actully là một chuỗi

• và độ dài đó nằm giữa giá trị tối thiểu và tối đa. Luôn kiểm tra các chuỗi cho kích thước tối đa mà chương trình của tôi có thể xử lý (trả lại các chuỗi quá lớn là một vấn đề bảo mật cổ điển trong các hệ thống nối mạng).

• Một số chuỗi cần được kiểm tra các ký tự hoặc nội dung "bất hợp pháp" khi có liên quan. Nếu chương trình của bạn có thể gửi chuỗi để nói cơ sở dữ liệu sau đó, thì nên kiểm tra các cuộc tấn công cơ sở dữ liệu (tìm kiếm SQL SQL). Các thử nghiệm này được thực hiện tốt nhất ở biên giới của hệ thống của tôi, nơi tôi có thể xác định được cuộc tấn công đến từ đâu và tôi có thể thất bại sớm. Thực hiện kiểm tra tiêm SQL đầy đủ có thể khó khăn khi các chuỗi được kết hợp sau đó, do đó kiểm tra nên được thực hiện trước khi gọi cơ sở dữ liệu, nhưng nếu bạn có thể tìm thấy một số vấn đề sớm thì có thể hữu ích.

Lý do để kiểm tra các tham số tôi gửi cho API là để đảm bảo rằng tôi nhận được kết quả chính xác. Một lần nữa, thực hiện các thử nghiệm này trước khi gọi API có vẻ không cần thiết nhưng hiệu suất rất ít và có thể gặp lỗi trong chương trình của tôi. Do đó các thử nghiệm có giá trị nhất khi phát triển một hệ thống (nhưng ngày nay mọi hệ thống dường như đang trong quá trình phát triển liên tục). Tùy thuộc vào các tham số, các kiểm tra có thể nhiều hoặc ít kỹ lưỡng hơn nhưng tôi có xu hướng thấy rằng bạn thường có thể đặt các giá trị tối thiểu và tối đa cho phép trên hầu hết các tham số mà chương trình của tôi có thể tạo. Có lẽ một chuỗi phải luôn có ít nhất 2 ký tự và dài tối đa 2000 ký tự? Tối thiểu và tối đa phải nằm trong những gì API cho phép vì tôi biết rằng chương trình của tôi sẽ không bao giờ sử dụng toàn bộ phạm vi của một số tham số.