SECURE APPLICATION PACKAGING IN THE CLOUD

Compiling a software application on a cloud computer system. An indication is received from a client at a cloud computer system. The indication comprises an indication that an uncompiled created software application is to be compiled. Receiving the indication includes receiving a document from the client, wherein the document comprises source code associated with the uncompiled created software application. The document is created at the client, wherein the client is at a location remote from the cloud computer system. In response to receiving the indication to compile the created software application, the document is compiled at the cloud computer system such that the compiled document is executable as a software application. The compiled document is then sent to the client for use as the software application, and stored in a cloud storage application repository such that sharing of compiled documents associated with executable software applications is possible.

BACKGROUND

Computer systems and related technology affect many aspects of society. Indeed, the computer system's ability to process information has transformed the way we live and work. Computer systems now commonly perform a host of tasks (e.g., word processing, scheduling, accounting, etc.) that prior to the advent of the computer system were performed manually. More recently, computer systems have been coupled to one another and to other electronic devices to form both wired and wireless computer networks over which the computer systems and other electronic devices can transfer electronic data. Accordingly, the performance of many computing tasks is distributed across a number of different computer systems and/or a number of different computing environments.

More recently, individuals and families have begun to acquire numerous computer systems and devices that may be used nearly constantly throughout a given day. For instance, an individual may have a smartphone, a tablet, a laptop, and a desktop, each of which may be used during the individual's daily routine. As such, individuals often share, download, upload, access, and/or transmit various video files, audio files, software applications, social media and so forth with others. Such constant use of transmitted electronic data each day causes a heightened risk of computer viruses infecting these numerous computer systems and devices. Furthermore, the constant sharing of such transmitted electronic data (e.g., video, audio, and so forth) allows viruses to be transmitted quickly, and oftentimes efficiently. As such, ensuring the safety of electronic data to be shared is critically important in the modern world.

BRIEF SUMMARY

At least some embodiments described herein relate to compiling a software application on a cloud computer system. For example, embodiments may include receiving an indication, at a cloud computer system, from a client that an uncompiled created software application is to be compiled. Receiving the indication includes receiving a document from the client, wherein the document comprises source code associated with the uncompiled created software application. The document is created at the client, wherein the client is at a location remote from the cloud computer system. In response to receiving the indication to compile the created software application, the document is compiled at the cloud computer system such that the compiled document is executable as a software application. The compiled document is then sent to the client for use as the software application, and stored in a cloud storage application repository such that sharing of compiled documents associated with executable software applications is possible.

Accordingly, a document acting as source code for an application created at a client computer system may be sent to a cloud service to be compiled. Compilation at the cloud service, rather than at a client computer system, may allow the cloud service to ensure that any document associated with a created application to be compiled is legitimate and secure. Once the legitimacy and security of the document is ensured by the cloud service, the cloud service may then compile the document. The cloud service can then ensure the integrity of the compiled document (i.e., the executable application), as well. The executable application may then be stored in an application repository to allow for viral sharing of the executable application. For instance, once stored in the application repository, an author of the application may share the application with other users, thus allowing those users to utilize the created executable application. In this way, packaging/compiling applications at a cloud service may ensure that any created executable application is trustworthy, and therefore secure with respect to viral sharing of the created executable application.

DETAILED DESCRIPTION

At least some embodiments described herein relate to compiling a software application on a cloud computer system. For example, embodiments may include receiving an indication, at a cloud computer system, from a client that an uncompiled created software application is to be compiled. Receiving the indication includes receiving a document from the client, wherein the document comprises source code associated with the uncompiled created software application. The document is created at the client, wherein the client is at a location remote from the cloud computer system. In response to receiving the indication to compile the created software application, the document is compiled at the cloud computer system such that the compiled document is executable as a software application. The compiled document is then sent to the client for use as the software application, and stored in a cloud storage application repository such that sharing of compiled documents associated with executable software applications is possible.

Accordingly, a document acting as source code for an application created at a client computer system may be sent to a cloud service to be compiled. Compilation at the cloud service, rather than at a client computer system, may allow the cloud service to ensure that any document associated with a created application to be compiled is legitimate and secure. Once the legitimacy and security of the document is ensured by the cloud service, the cloud service may then compile the document. The cloud service can then ensure the integrity of the compiled document (i.e., the executable application), as well. The executable application may then be stored in an application repository to allow for viral sharing of the executable application. For instance, once stored in the application repository, an author of the application may share the application with other users, thus allowing those users to utilize the created executable application. In this way, packaging/compiling applications at a cloud service may ensure that any created executable application is trustworthy, and therefore secure with respect to viral sharing of the created executable application.

Some introductory discussion of a computing system will be described with respect toFIG. 1. Then packaging applications at a cloud computer service will be described with respect toFIGS. 2 and 3.

Computing systems are now increasingly taking a wide variety of forms. Computing systems may, for example, be handheld devices, appliances, laptop computers, desktop computers, mainframes, distributed computing systems, datacenters, or even devices that have not conventionally been considered a computing system, such as wearables (e.g., glasses). In this description and in the claims, the term “computing system” is defined broadly as including any device or system (or combination thereof) that includes at least one physical and tangible processor, and a physical and tangible memory capable of having thereon computer-executable instructions that may be executed by a processor. The memory may take any form and may depend on the nature and form of the computing system. A computing system may be distributed over a network environment and may include multiple constituent computing systems.

As illustrated inFIG. 1, in its most basic configuration, a computing system100typically includes at least one hardware processing unit102and memory104. The memory104may be physical system memory, which may be volatile, non-volatile, or some combination of the two. The term “memory” may also be used herein to refer to non-volatile mass storage such as physical storage media. If the computing system is distributed, the processing, memory and/or storage capability may be distributed as well.

The computing system100also has thereon multiple structures often referred to as an “executable component”. For instance, the memory104of the computing system100is illustrated as including executable component106. The term “executable component” is the name for a structure that is well understood to one of ordinary skill in the art in the field of computing as being a structure that can be software, hardware, or a combination thereof. For instance, when implemented in software, one of ordinary skill in the art would understand that the structure of an executable component may include software objects, routines, methods, and so forth, that may be executed on the computing system, whether such an executable component exists in the heap of a computing system, or whether the executable component exists on computer-readable storage media.

The term “executable component” is also well understood by one of ordinary skill as including structures that are implemented exclusively or near-exclusively in hardware, such as within a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), or any other specialized circuit. Accordingly, the term “executable component” is a term for a structure that is well understood by those of ordinary skill in the art of computing, whether implemented in software, hardware, or a combination. In this description, the terms “component”, “service”, “engine”, “module”, “control”, “signature generator”, “key generator” or the like may also be used. As used in this description and in the case, these terms (whether expressed with or without a modifying clause) are also intended to be synonymous with the term “executable component”, and thus also have a structure that is well understood by those of ordinary skill in the art of computing.

In the description that follows, embodiments are described with reference to acts that are performed by one or more computing systems. If such acts are implemented in software, one or more processors (of the associated computing system that performs the act) direct the operation of the computing system in response to having executed computer-executable instructions that constitute an executable component. For example, such computer-executable instructions may be embodied on one or more computer-readable media that form a computer program product. An example of such an operation involves the manipulation of data.

The computer-executable instructions (and the manipulated data) may be stored in the memory104of the computing system100. Computing system100may also contain communication channels108that allow the computing system100to communicate with other computing systems over, for example, network110.

While not all computing systems require a user interface, in some embodiments, the computing system100includes a user interface112for use in interfacing with a user. The user interface112may include output mechanisms112A as well as input mechanisms112B. The principles described herein are not limited to the precise output mechanisms112A or input mechanisms112B as such will depend on the nature of the device. However, output mechanisms112A might include, for instance, speakers, displays, tactile output, holograms and so forth. Examples of input mechanisms112B might include, for instance, microphones, touchscreens, holograms, cameras, keyboards, mouse of other pointer input, sensors of any type, and so forth.

FIG. 2illustrates a computer environment210for performing the packaging of an application at a cloud computer service.FIG. 2includes client computer system210. Client computer system210may comprise any type of computer system, including a mobile device (e.g., a smartphone, a tablet, and so forth), a laptop computer, a desktop computer, and so forth. Furthermore, client computer system210may run any operating system, whether currently developed or to be developed in the future, including MICROSOFT® WINDOWS®, APPLE® OS X®, APPLE IOS®, GOOGLE™ CHROME OS™, UBUNTU®, LINUX®, and so forth. Alternatively, client computer system210may comprise a website, web service, web application, desktop application, mobile application, and so forth. In yet W other embodiments, the client computer system210may be a combination of a computer system (e.g., a laptop computer) running an application (e.g., a desktop application, a website, a web service, a web application, a mobile application, and so forth).

FIG. 2also includes cloud service220. Cloud service220may be any applicable type of cloud computer system that is remote from the client210. For example, cloud service220may comprise MICROSOFT AZURE®, AMAZON WEB SERVICES®, and so forth. As shown,FIG. 2also includes application repository230, which may be capable of storing any application created at client computer system210. Additionally, application repository230may allow for viral sharing of any application stored within the application repository, as further described herein. While application repository230is shown inFIG. 2as being separate from cloud service220, application repository230may instead be included within cloud service220.

FIG. 2also includes document212and packaged/compiled executable application222. Executable application222is a compiled and executable version of the document212, as described more fully herein. Document212may be a non-executable declarative document that functions as source code for a created application. As such, document212may include one or more declarative expressions that comprise easy-to-use programming languages and expressions (i.e., declarative language). For instance, such declarative expressions may be similar to the expressions used in MICROSOFT EXCEL®. Additionally, the document212may have an underlying transformation chain. A transformation chain is an interconnected set of nodes that each may represent data sources or data targets. There are links between the nodes, each link representing a transformation.

For instance, a transformation of the transformation chain may be declaratively defined when creating an application. For any given link, the associated transformation receives copies of values of one or more data sources situated at an input end to the link, and generates resulting values being provided at one or more data targets located at the output end of the link. For any given transformation, when a value at one or more of the data sources at its input end changes, the transformation is automatically reevaluated, potentially resulting in changes in value(s) of one or more data targets at the output end of the transformation.

An input node of a transformation chain may be, for instance, a sensor, a data source, or a UI control that receives input. An output node of a transformation chain may be, for instance, a data target, a visualization, or a UI control that outputs data. In one embodiment, regardless of how complex the transformation chain is, the transformations may be constructed from declarative statements expressing equations, rules, constraints, simulations, or any other transformation type that may receive one or more values as input and provide resulting one or more values as output. Transformation chains may be augmented as a program is built by linking different transformation chains to honor the dependencies between the chains. In some embodiments, such dependencies may be declaratively defined using a function editor when creating an application. As such, as an author builds an application incrementally, the transformation chain that represents the application likewise augments incrementally.

As briefly described, an application may be created at client computer system210. Once an application has been created at client computer system210, the application may be packaged by cloud service220. The cloud service220may then store the packaged executable application within application repository230, which application repository may be included within cloud service220or comprise a standalone service.

In a specific example, client210may be a computer system running MICRSOFT POWERAPPS™ (POWERAPPS). When a user has created an application, a document212associated with the created application (i.e., source code of the application) may be concurrently created. As such, once the user has created the application using POWERAPPS and indicates to the client210a desire to use the created application, document212may be sent to cloud service220for packaging/compilation. In some embodiments, document212may be sent to the cloud service220to be packaged/compiled when the user attempts to save the application. In other embodiments, document212may be sent to the cloud service220to be packaged/compiled when the user attempts to publish the created application for use by the user and/or others.

Once the cloud service220has received the document212, the cloud service220and/or the application repository230may determine whether packaging/compiling has already been performed with respect to the received document. If cloud service220and/or the application repository230determine that document212has already been packaged/compiled, the cloud service220and/or the application repository230may fetch the packaged/compiled executable application222, and send the executable application to the client210. On the other hand, if the cloud service220and/or application repository230determine that the received document212has not been compiled, the cloud service may compile the document212to create an executable application222.

In some embodiments, the document212may be compiled to execute in any number of different environments. As such, packaged executable application222a may be created such that the single packaged executable application can be executed in any computing environment (e.g., a desktop browser, a mobile application, a desktop application, and so forth). In other embodiments, the document212may be compiled to execute only in the environment (e.g., web application, mobile application, desktop application, and so forth) in which a user has requested the executable application222is to be executed. For instance, a user may request to publish an application such that the packaged executable application222may execute in a desktop browser. In another embodiment, a user may request to package an application to run on a particular desktop browser. In such an instance, a document212associated with the created application may be specifically packaged/tailored for execution in the particular desktop browser environment. While the previous example is discussed in regards to a desktop browser, the example may also apply to specific desktop operating systems, mobile operating systems, mobile hardware/devices, desktop hardware/devices, and so forth.

As illustrated inFIG. 2, upon packaging/compilation of document212into executable application222, the executable application222may also be sent to application repository230for storage. Once the executable application222is stored in application repository222, the user (or owner) of the executable application222may share the executable application with others such that those who have been given permission by the user can access the executable application from the application repository230. Those users who have been given permission by the user may then consume/utilize the created application.

While, packaging an application in the cloud has been described as first sending the document212to cloud service220, the document may first be sent to an application repository230. The application repository230may then send the a document212to cloud service220. In such instances, cloud service220may comprise a cloud service specifically created for application packaging. The cloud service may then package/compile the document212in order to generate an executable application222. The cloud service may then send the executable application222to the application repository230, where the executable application can be stored. Finally, the application repository may then send the packaged executable application to the user for consumption, sharing, and so forth of the executable application.

In some embodiments, the executable application222may comprise JAVASCRIPT® and/or hypertext markup language (HTML). While the executable application222is discussed as including JAVASCRIPT and/or HTML, the executable application may include any one or more suitable computer-executable languages, whether currently developed or to be developed in the future. However, regardless of the language(s) used in the executable application222, performing the packaging of document212at cloud service220may improve the security and trustworthiness of the executable application222. Additionally, saving the executable application222in application repository230may facilitate viral sharing. For example, once a user has created an application, the application (i.e., the document212) has been compiled to create an executable application222, the user may share the executable application222with other users. Those other users may then access (e.g., download) the executable application222from the application repository230for use of the executable application by the other users.

As such, if packaging/compilation were to be performed on client computer system210, while still storing the resulting executable application(s) in application repository230, a malicious client may be able to tamper with the executable application (i.e., generated code associated with the executable application) before transmitting it to the application repository230for viral sharing. For instance, assume that application repository230simply identifies whether any particular received (and already compiled) application is comprised of JAVASCRIPT in order to accept and store the received application. In such an instance, a user could create a malicious JAVASCRIPT file that appears to be an application. In response, the application repository230may accept and store the malicious file, which could then be shared with others. Accordingly, sending the document212(i.e., the source code of a created application) to cloud service220for packaging/compiling (rather than packaging/compiling at the client) may allow the cloud service to ensure that any executable application222is a legitimate, secure application before storing the executable application in application repository230for viral sharing.

In some embodiments, each time a document212associated with a particular created application is packaged/compiled, the resulting packaged executable application222may be a unique executable application having a unique version number. A packaged executable application222may be assigned a unique version number based on a version of the document212that is sent to cloud service220. In an example, assume a user has created an application and attempted to publish the created application. The packaged executable application resulting from that attempt to publish will be assigned a first unique version number. When the user decides to modify that created application and again attempts to publish, the resulting packaged executable application may be assigned a second unique version number. Accordingly, each time a user changes a created application and attempts to publish the changed application, the resulting packaged executable application may be assigned a unique version number that is different from any other version of the

Alternatively, a packaged executable application222may be assigned a unique version number based on which client/user is requesting the packaged executable application. For example, when an author of a created application requests to publish the created application, the resulting packaged executable application may be assigned a first unique version number. When a user who has been authorized by the author to access the created application requests to access the application, a different packaged executable application having a second unique version number may be generated/compiled. In yet other embodiments, both the document version and the particular client/user requesting the packaged executable application may be considered in assigning the resulting executable application a unique version number.

Each version of the packaged executable applications may then be stored and cached by cloud service220and/or application repository230. Accordingly, if a packaged executable application having a version number corresponding to the particular version of the document212, the particular user making the request, or both (depending on the combination of factors being used) has already been compiled, cloud service220and/or application repository230may provide that particular packaged executable application. If such a packaged executable application does not exist, cloud service220may package/compile the received document212and provide the packaged executable application222to the user.

In some embodiments, a created application may also include assets, including images, video, audio, and so forth. Such assets may be stored on client computer system210, within a cloud storage service, or any other type of data storage. Regardless of where assets to be used in a particular created application are stored, such assets may be uploaded to cloud service220and/or application repository230prior to compilation of the document212associated with the particular created application, so that the cloud service220has access to the assets during compilation.

FIG. 3illustrates an example method300for packaging/compiling a software application on a cloud computer system. As such, frequent reference will be made to the computing environment200ofFIG. 2. The method300includes receiving, at cloud service220, an indication from a client210that an uncompiled created software application (i.e., document212) is to be compiled, wherein receiving the indication includes receiving a document from the client (Act310). Such an indication from the client210may comprise an indication that the user has saved the created application, has requested that the created application be published, or has performed any other similar action showing a desire to create an executable application associated with the created application. As described herein, the document may comprise source code associated with the uncompiled created software application (i.e., the document). Additionally, the document may be created at the client computer system210, which client computer system may be at a remote location with respect to the cloud service220. For example, a user may have created an application in POWERAPPS and attempted to publish the application for use by the user and/or others.

In response to receiving the indication to compile the created software application, the document may be compiled at the cloud service220such that the compiled document is executable as a software application (Act320). The compiled document (i.e., the executable application222) may then be sent to the client for use as the software application (Act330). In the ongoing example, the application created by the user at client210using POWERAPPS may be packaged/compiled at cloud service220and sent to client210for consumption of the application by the user.

The compiled document may then be stored in a cloud storage application repository230such that sharing of compiled documents associated with executable software applications is possible (Act340). In the ongoing example, the user may share the created executable application222with other users by giving the other users permission(s) associated with accessing and utilizing the created executable application. Accordingly, once another user has been given permission to access/utilize the created executable application222, the permitted user may access the executable application via application repository230.

Accordingly, a declarative document acting as source code for an application created at a client computer system may be sent to a cloud service to be compiled. Compilation at the cloud service, rather than at a client computer system, may allow the cloud service to ensure that any document associated with a created application to be compiled is legitimate and secure. Once the legitimacy and security of the document is ensured by the cloud service, the cloud service may then compile the document. The cloud service can then ensure the integrity of the packaged and compiled document (i.e., the executable application), as well. In other words, the cloud service can ensure that the packaged and compiled document is safe for use and sharing by users. The executable application may then be stored in an application repository to allow for viral sharing of the executable application. For instance, once stored in the application repository, an author of the application may share the application with other users, thus allowing those users to utilize the created executable application. In this way, packaging/compiling applications at a cloud service may ensure that any created executable application is trustworthy, and therefore secure with respect to viral sharing of the created executable application.