When storing or reading data from a disk, or when making API calls, does your app's sole validation of data involve ensuring that the JSON can be decoded?
How do you receive email addresses in your JSON? Do you use a simple string variable?
There is a high likelihood that your current JSON is not as secure as it could be. When combined with other vulnerabilities in libraries and operating systems, a wide range of undesirable outcomes, from crashes to compromised user devices, may arise due to insecure JSON handling.
Typical “Client” struct
Let's envision a scenario where we need to obtain a list of prospective clients from an API, which includes their names, ages, and email addresses.
[{"name":"John Doe","age":35,"email":"john@doe.test"}]
It would be typical to expect the following associated code:
struct Client: Codable {
let name: String
let age: Int
let email: String
}
func decodeClientList(data: Data) throws -> [Client] {
return try JSONDecoder().decode([Client].self, from: data)
}
Unfortunately, this allows for various inputs that don't make sense in our context. For instance, does it make sense for a client's age to be 150,000 years old? Yet, your JSON permits it. Similarly, the email address could be set to "Hello" in the JSON, and the decoder wouldn't raise any issues.
You may need to perform validation on the Client data after it has been decoded. Additionally, remember to re-validate the data when retrieving it from CoreData later on or when accessing it through your caching layer.
Instead, you could declare your Codable in such a way that validation is performed while decoding.
Age
Let’s begin by defining the minimum and maximum age for your clients.
Any “age” value higher than 150 is likely a mistake and shouldn’t be allowed.
Negative values are clearly out of the question (you could use UInt..)
You might even want to set a minimum value, let’s go with 1 for now
struct Age: Codable {
let value: Int
enum Errors: Error {
case outOfRange
}
static let minimumAge = 1
static let maximumAge = 150
@discardableResult
static func evaluated(_ age: Int) throws -> Int {
guard (minimumAge...maximumAge).contains(age) else {
throw Errors.outOfRange
}
return age
}
init(from decoder: Decoder) throws {
let age = try decoder
.singleValueContainer()
.decode(Int.self)
self.value = try Age.evaluated(age)
}
}
In the code above, we have created a struct that contains an integer value representing age, and we have defined the errors that will be thrown if the value does not meet our criteria. We then proceed to create a static function that evaluates the value against our criteria.
The purpose of using a static function for evaluation outside the decoder is that it can be reused in other initializers or anywhere within our app where we need to determine if a value meets the criteria.
Finally for the Age struct, we define the initializer, that extracts the value, evaluates and stores it.
Name
After taking some time to reflect on client names, I realize that I'm not aware of anyone having a name longer than 100 characters, and certainly no one with a name exceeding 500 characters. It's also safe to assume that no one has an "@" symbol or a backslash in their name. Defining some rules, we obtain:
Can contain alphabetical characters (from various alphabets and languages)
Can contain spaces but only between the names
Should contain at least 2 characters
Should be no longer than 100
struct Name: Codable {
let value: String
enum Errors: Error {
case tooShortOrTooLong
case invalidCharacters
}
static let minimumTrimmedLength = 2
static let maximumTrimmedLength = 100
static let allowedCharacters: CharacterSet = .alphanumerics
.union(.whitespaces)
@discardableResult
static func evaluated(_ name: String) throws -> String {
let trimmed = name.trimmingCharacters(in: .whitespacesAndNewlines)
guard (1...100).contains(trimmed.count) else {
throw Errors.tooShortOrTooLong
}
let disallowedCharacters = allowedCharacters.inverted
guard trimmed.rangeOfCharacter(from: disallowedCharacters) == nil else {
throw Errors.invalidCharacters
}
return trimmed
}
init(from decoder: Decoder) throws {
let string = try decoder
.singleValueContainer()
.decode(String.self)
self.value = try Name.evaluated(string)
}
}
We begin the same way by defining the criteria and possible evaluation errors. Followed by the static function to perform the evaluation and the initializer.
Email
Emails are one of the hardest to validate by syntax alone, and this can clearly be seen by the sheer amount of RegEx that exists, all different from one another, to perform the same task.. all succeeding or failing to various degrees. Ref: https://stackoverflow.com/questions/156430/is-regular-expression-recognition-of-an-email-address-hard
If you are looking for a strong Email syntax validation library, consider usingSwiftEmailValidatoravailable for free on GitHub.
import SwiftEmailValidator
struct Email: Codable {
let value: String
enum Errors: Error {
case incorrectlyFormatted
}
@discardableResult
static func evaluated(_ string: String) throws -> String {
let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
guard EmailSyntaxValidator.correctlyFormatted(trimmed) else {
throw incorrectlyFormatted
}
return trimmed
}
init(from decoder: Decoder) throws {
let string = try decoder
.singleValueContainer()
.decode(String.self)
self.value = try Email.evaluated(string)
}
}
Secure “Client” struct
We can now go in our original Client struct and update the struct to use our new Codable values:
struct Client: Codable {
let name: Name
let age: Age
let email: Email
}
func decodeClientList(data: Data) throws -> [Client] {
return try JSONDecoder().decode([Client].self, from: data)
}
Conclusion
It is fairly easy to greatly improve our handling of JSON data by defining custom data types with their own evaluation rules and initializers.
Remember that validation rules need to be evaluated against:
Your business requirements
Intended demographics
RFC documents
Other libraries with which you interact (maximum variable length, CoreData SQL injections, …)
Other restrictions imposed by the database administrator, API, etc…
Finally, always define unit tests to validate that your code works as intended.
